1656 lines
62 KiB
JavaScript
1656 lines
62 KiB
JavaScript
(function() {
|
||
var MAX_FILE_BYTES = 256 * 1024;
|
||
var APPLY_REPLAY_STORAGE_KEY = 'crank_openapi_plan_apply_replay_v2';
|
||
var restoredApplyRequest = loadApplyReplay();
|
||
var state = {
|
||
workspaceId: null,
|
||
onImported: null,
|
||
file: null,
|
||
jobId: null,
|
||
preview: null,
|
||
existingOperations: [],
|
||
operationsReady: false,
|
||
decisions: Object.create(null),
|
||
plan: null,
|
||
filterQuery: '',
|
||
filterMethod: '',
|
||
revision: 0,
|
||
previewController: null,
|
||
planController: null,
|
||
applyController: null,
|
||
applyInFlight: false,
|
||
applyRequest: restoredApplyRequest,
|
||
applyMetadata: restoredApplyRequest && restoredApplyRequest.operationMetadata || [],
|
||
applyResult: null,
|
||
applyOutcomeUnknown: !!restoredApplyRequest,
|
||
applyRefreshFailed: false,
|
||
restoreFocus: null,
|
||
};
|
||
|
||
function validApplyReplay(request) {
|
||
return request
|
||
&& typeof request.workspaceId === 'string' && request.workspaceId.length > 0 && request.workspaceId.length <= 128
|
||
&& typeof request.planReference === 'string' && request.planReference.length > 0 && request.planReference.length <= 128
|
||
&& typeof request.planDigest === 'string' && /^[a-f0-9]{64}$/.test(request.planDigest)
|
||
&& typeof request.idempotencyKey === 'string' && request.idempotencyKey.length > 0 && request.idempotencyKey.length <= 128;
|
||
}
|
||
|
||
function loadApplyReplay() {
|
||
try {
|
||
var request = JSON.parse(sessionStorage.getItem(APPLY_REPLAY_STORAGE_KEY) || 'null');
|
||
return validApplyReplay(request) ? request : null;
|
||
} catch (_error) {
|
||
return null;
|
||
}
|
||
}
|
||
|
||
function persistApplyReplay(request) {
|
||
if (!validApplyReplay(request)) return;
|
||
try {
|
||
sessionStorage.setItem(APPLY_REPLAY_STORAGE_KEY, JSON.stringify(request));
|
||
} catch (_error) {}
|
||
}
|
||
|
||
function clearApplyReplay() {
|
||
try {
|
||
sessionStorage.removeItem(APPLY_REPLAY_STORAGE_KEY);
|
||
} catch (_error) {}
|
||
}
|
||
|
||
function qs(id) {
|
||
return document.getElementById(id);
|
||
}
|
||
|
||
function tKey(key) {
|
||
return window.t ? window.t(key) : key;
|
||
}
|
||
|
||
function tfKey(key, vars) {
|
||
return window.tf ? window.tf(key, vars) : tKey(key);
|
||
}
|
||
|
||
function locale() {
|
||
return localStorage.getItem('crank_lang') === 'ru' ? 'ru' : 'en';
|
||
}
|
||
|
||
function isSameContext(revision, workspaceId, language) {
|
||
return revision === state.revision
|
||
&& workspaceId === state.workspaceId
|
||
&& language === locale();
|
||
}
|
||
|
||
function isCurrent(revision, workspaceId, language) {
|
||
return isSameContext(revision, workspaceId, language)
|
||
&& !qs('openapi-import-modal').hidden;
|
||
}
|
||
|
||
function setStatus(message, isError, focus) {
|
||
var node = qs('openapi-import-status');
|
||
if (!node) return;
|
||
|
||
node.textContent = message || '';
|
||
node.classList.toggle('error', !!isError);
|
||
|
||
if (focus && message) {
|
||
node.focus();
|
||
}
|
||
}
|
||
|
||
function boundedFileName(file) {
|
||
var name = String(file && file.name || '');
|
||
return name.length > 128 ? name.slice(0, 127) + '…' : name;
|
||
}
|
||
|
||
function formatSize(bytes) {
|
||
var language = locale() === 'ru' ? 'ru-RU' : 'en-US';
|
||
return new Intl.NumberFormat(language).format(bytes) + ' B';
|
||
}
|
||
|
||
function renderFileName() {
|
||
var node = qs('openapi-import-file-name');
|
||
|
||
if (!node) return;
|
||
node.textContent = state.file
|
||
? boundedFileName(state.file) + ' · ' + formatSize(state.file.size)
|
||
: tKey('openapi.file.none');
|
||
}
|
||
|
||
function selectedKeys() {
|
||
return Array.from(document.querySelectorAll('[data-openapi-operation]:checked'))
|
||
.map(function(input) {
|
||
return input.value;
|
||
});
|
||
}
|
||
|
||
function importOperations() {
|
||
return (state.preview && state.preview.groups || []).flatMap(function(group) {
|
||
return group.operations || [];
|
||
});
|
||
}
|
||
|
||
function decisionFor(operationKey) {
|
||
if (!state.decisions[operationKey]) {
|
||
state.decisions[operationKey] = { action: 'create', targetOperationId: '', confirmedName: '' };
|
||
}
|
||
return state.decisions[operationKey];
|
||
}
|
||
|
||
function matchingOperations(operation) {
|
||
return state.existingOperations.filter(function(existing) {
|
||
return existing.name === operation.suggested_name;
|
||
});
|
||
}
|
||
|
||
function renderDecisionControls(operation, row) {
|
||
var previous = row.querySelector('.openapi-import-decision-controls');
|
||
if (previous) previous.remove();
|
||
|
||
var controls = document.createElement('div');
|
||
var actionLabel = document.createElement('label');
|
||
var actionSelect = document.createElement('select');
|
||
var candidateDecision = decisionFor(operation.key);
|
||
var matches = matchingOperations(operation);
|
||
var versionable = matches.filter(function(existing) {
|
||
return existing.protocol === 'rest' && existing.status !== 'archived';
|
||
});
|
||
var actions = [
|
||
['create', 'openapi.decision.create'],
|
||
['skip', 'openapi.decision.skip'],
|
||
['rename', 'openapi.decision.rename'],
|
||
['new_version', 'openapi.decision.new_version'],
|
||
];
|
||
|
||
controls.className = 'openapi-import-decision-controls';
|
||
actionLabel.textContent = tKey('openapi.decision.action_label');
|
||
actionLabel.htmlFor = 'openapi-import-decision-' + operation.key;
|
||
actionSelect.id = actionLabel.htmlFor;
|
||
actionSelect.dataset.openapiDecisionAction = operation.key;
|
||
actions.forEach(function(spec) {
|
||
var option = document.createElement('option');
|
||
option.value = spec[0];
|
||
option.textContent = tKey(spec[1]);
|
||
if ((spec[0] === 'skip' && !matches.length)
|
||
|| (spec[0] === 'new_version' && !versionable.length)) {
|
||
option.disabled = true;
|
||
}
|
||
actionSelect.appendChild(option);
|
||
});
|
||
actionSelect.value = candidateDecision.action;
|
||
actionSelect.addEventListener('change', function() {
|
||
candidateDecision.action = actionSelect.value;
|
||
if (candidateDecision.action === 'skip' || candidateDecision.action === 'new_version') {
|
||
var allowed = candidateDecision.action === 'new_version' ? versionable : matches;
|
||
if (!allowed.some(function(existing) { return existing.id === candidateDecision.targetOperationId; })) {
|
||
candidateDecision.targetOperationId = allowed.length === 1 ? allowed[0].id : '';
|
||
}
|
||
}
|
||
renderDecisionControls(operation, row);
|
||
});
|
||
actionLabel.appendChild(actionSelect);
|
||
controls.appendChild(actionLabel);
|
||
|
||
if (candidateDecision.action === 'skip' || candidateDecision.action === 'new_version') {
|
||
var targetLabel = document.createElement('label');
|
||
var targetSelect = document.createElement('select');
|
||
var allowedTargets = candidateDecision.action === 'new_version' ? versionable : matches;
|
||
var placeholder = document.createElement('option');
|
||
targetLabel.textContent = tKey('openapi.decision.target_label');
|
||
targetSelect.dataset.openapiDecisionTarget = operation.key;
|
||
placeholder.value = '';
|
||
placeholder.textContent = tKey('openapi.decision.target_placeholder');
|
||
targetSelect.appendChild(placeholder);
|
||
allowedTargets.forEach(function(existing) {
|
||
var option = document.createElement('option');
|
||
option.value = existing.id;
|
||
option.textContent = existing.name + ' · ' + existing.id;
|
||
targetSelect.appendChild(option);
|
||
});
|
||
targetSelect.value = candidateDecision.targetOperationId;
|
||
targetSelect.addEventListener('change', function() {
|
||
candidateDecision.targetOperationId = targetSelect.value;
|
||
});
|
||
targetLabel.appendChild(targetSelect);
|
||
controls.appendChild(targetLabel);
|
||
}
|
||
|
||
if (candidateDecision.action === 'rename') {
|
||
var renameLabel = document.createElement('label');
|
||
var renameInput = document.createElement('input');
|
||
renameLabel.textContent = tKey('openapi.decision.confirmed_name_label');
|
||
renameInput.type = 'text';
|
||
renameInput.maxLength = 128;
|
||
renameInput.value = candidateDecision.confirmedName;
|
||
renameInput.placeholder = tKey('openapi.decision.confirmed_name_placeholder');
|
||
renameInput.dataset.openapiDecisionName = operation.key;
|
||
renameInput.addEventListener('input', function() {
|
||
candidateDecision.confirmedName = renameInput.value;
|
||
});
|
||
renameLabel.appendChild(renameInput);
|
||
controls.appendChild(renameLabel);
|
||
}
|
||
|
||
row.appendChild(controls);
|
||
}
|
||
|
||
function operationRows() {
|
||
return Array.from(document.querySelectorAll('.openapi-import-operation'));
|
||
}
|
||
|
||
function visibleOperationRows() {
|
||
return operationRows().filter(function(row) {
|
||
return !row.hidden;
|
||
});
|
||
}
|
||
|
||
function updateSelection() {
|
||
var node = qs('openapi-import-selection');
|
||
var selectedCount = selectedKeys().length;
|
||
var totalCount = document.querySelectorAll('[data-openapi-operation]').length;
|
||
var visibleCount = visibleOperationRows().length;
|
||
|
||
if (node) {
|
||
node.textContent = tfKey('openapi.selection', {
|
||
selected: selectedCount,
|
||
total: totalCount,
|
||
visible: visibleCount,
|
||
});
|
||
}
|
||
|
||
document.querySelectorAll('.openapi-import-group').forEach(function(groupNode) {
|
||
var rows = Array.from(groupNode.querySelectorAll('.openapi-import-operation'));
|
||
var visibleInputs = rows
|
||
.filter(function(row) { return !row.hidden; })
|
||
.map(function(row) { return row.querySelector('[data-openapi-operation]'); })
|
||
.filter(Boolean);
|
||
var selectedVisible = visibleInputs.filter(function(input) {
|
||
return input.checked;
|
||
}).length;
|
||
var selectedTotal = rows.filter(function(row) {
|
||
var input = row.querySelector('[data-openapi-operation]');
|
||
return input && input.checked;
|
||
}).length;
|
||
var checkbox = groupNode.querySelector('[data-openapi-group]');
|
||
var counter = groupNode.querySelector('[data-openapi-group-count]');
|
||
|
||
if (checkbox) {
|
||
checkbox.indeterminate = selectedVisible > 0 && selectedVisible < visibleInputs.length;
|
||
checkbox.checked = visibleInputs.length > 0 && selectedVisible === visibleInputs.length;
|
||
}
|
||
|
||
if (counter) {
|
||
counter.textContent = tfKey('openapi.group.selection', {
|
||
selected: selectedTotal,
|
||
total: rows.length,
|
||
visible: visibleInputs.length,
|
||
});
|
||
}
|
||
});
|
||
}
|
||
|
||
function applyFilters() {
|
||
var query = state.filterQuery.toLowerCase();
|
||
var method = state.filterMethod.toLowerCase();
|
||
|
||
document.querySelectorAll('.openapi-import-group').forEach(function(groupNode) {
|
||
var visibleInGroup = 0;
|
||
|
||
groupNode.querySelectorAll('.openapi-import-operation').forEach(function(row) {
|
||
var matchesMethod = !method || String(row.dataset.openapiMethod).toLowerCase() === method;
|
||
var matchesQuery = !query || String(row.dataset.openapiSearch).toLowerCase().indexOf(query) >= 0;
|
||
var visible = matchesMethod && matchesQuery;
|
||
|
||
row.hidden = !visible;
|
||
if (visible) visibleInGroup += 1;
|
||
});
|
||
|
||
groupNode.hidden = visibleInGroup === 0;
|
||
});
|
||
|
||
updateSelection();
|
||
}
|
||
|
||
function setVisibleSelection(checked) {
|
||
visibleOperationRows().forEach(function(row) {
|
||
var input = row.querySelector('[data-openapi-operation]');
|
||
if (input) input.checked = checked;
|
||
});
|
||
|
||
updateSelection();
|
||
}
|
||
|
||
function escapeHtml(value) {
|
||
return String(value || '')
|
||
.replace(/&/g, '&')
|
||
.replace(/</g, '<')
|
||
.replace(/>/g, '>')
|
||
.replace(/"/g, '"');
|
||
}
|
||
|
||
function renderFinding(finding) {
|
||
var severity = String(finding && finding.severity || 'warning').toLowerCase();
|
||
var label = severity === 'info' ? 'i' : severity === 'error' ? '×' : '!';
|
||
|
||
return '<span class="openapi-import-finding openapi-import-finding-' + escapeHtml(severity) + '">'
|
||
+ '<strong>' + label + '</strong> '
|
||
+ escapeHtml(findingMessage(finding))
|
||
+ '</span>';
|
||
}
|
||
|
||
function findingMessage(finding) {
|
||
var code = String(finding && finding.code || '').replace(/^.*\./, '');
|
||
var known = {
|
||
missing_servers: 'openapi.finding.missing_servers',
|
||
multiple_servers: 'openapi.finding.multiple_servers',
|
||
unsupported_request_body: 'openapi.finding.unsupported_request_body',
|
||
operation_name_renamed: 'openapi.finding.operation_name_renamed',
|
||
operation_name_conflict: 'openapi.finding.operation_name_conflict',
|
||
weak_tool_description: 'openapi.finding.weak_tool_description',
|
||
};
|
||
|
||
return tKey(known[code] || 'openapi.finding.generic');
|
||
}
|
||
|
||
function appendMappingGroup(root, label, values) {
|
||
if (!values || !values.length) return;
|
||
|
||
var group = document.createElement('div');
|
||
group.className = 'openapi-import-mapping-group';
|
||
|
||
var title = document.createElement('span');
|
||
title.className = 'openapi-import-mapping-label';
|
||
title.textContent = label;
|
||
group.appendChild(title);
|
||
|
||
values.slice(0, 8).forEach(function(value) {
|
||
var chip = document.createElement('code');
|
||
chip.className = 'openapi-import-mapping-chip';
|
||
chip.textContent = value;
|
||
group.appendChild(chip);
|
||
});
|
||
|
||
if (values.length > 8) {
|
||
var more = document.createElement('span');
|
||
more.className = 'openapi-import-mapping-more';
|
||
more.textContent = '+' + (values.length - 8);
|
||
group.appendChild(more);
|
||
}
|
||
|
||
root.appendChild(group);
|
||
}
|
||
|
||
function renderOperationMappingPreview(operation) {
|
||
var details = document.createElement('div');
|
||
var request = { path: [], query: [], headers: [], body: [] };
|
||
var inputRules = operation
|
||
&& operation.draft
|
||
&& operation.draft.input_mapping
|
||
&& Array.isArray(operation.draft.input_mapping.rules)
|
||
? operation.draft.input_mapping.rules
|
||
: [];
|
||
var outputRules = operation
|
||
&& operation.draft
|
||
&& operation.draft.output_mapping
|
||
&& Array.isArray(operation.draft.output_mapping.rules)
|
||
? operation.draft.output_mapping.rules
|
||
: [];
|
||
|
||
details.className = 'openapi-import-mapping-preview';
|
||
|
||
inputRules.forEach(function(rule) {
|
||
var target = String(rule.target || '');
|
||
|
||
if (target.indexOf('$.request.path.') === 0) {
|
||
request.path.push(target.slice(15));
|
||
} else if (target.indexOf('$.request.query.') === 0) {
|
||
request.query.push(target.slice(16));
|
||
} else if (target.indexOf('$.request.headers.') === 0) {
|
||
request.headers.push(target.slice(18));
|
||
} else if (target.indexOf('$.request.body.') === 0) {
|
||
request.body.push(target.slice(15));
|
||
} else if (target === '$.request.body') {
|
||
request.body.push('body');
|
||
}
|
||
});
|
||
|
||
appendMappingGroup(details, tKey('openapi.mapping.path'), request.path);
|
||
appendMappingGroup(details, tKey('openapi.mapping.query'), request.query);
|
||
appendMappingGroup(details, tKey('openapi.mapping.header'), request.headers);
|
||
appendMappingGroup(details, tKey('openapi.mapping.body'), request.body);
|
||
appendMappingGroup(details, tKey('openapi.mapping.response'), outputRules.map(function(rule) {
|
||
var target = String(rule.target || '').replace('$.output.', '').replace('$.output', 'result');
|
||
var source = String(rule.source || '').replace('$.response.body.', '').replace('$.response.body', 'body');
|
||
return target + ' ← ' + source;
|
||
}));
|
||
|
||
return details;
|
||
}
|
||
|
||
function populateServers(preview) {
|
||
var serverSelect = qs('openapi-import-server');
|
||
var servers = preview.source && preview.source.servers && preview.source.servers.length
|
||
? preview.source.servers
|
||
: [''];
|
||
|
||
serverSelect.replaceChildren();
|
||
servers.forEach(function(server) {
|
||
var option = document.createElement('option');
|
||
option.value = server;
|
||
option.textContent = server || tKey('openapi.server.required');
|
||
serverSelect.appendChild(option);
|
||
});
|
||
}
|
||
|
||
function populateMethodFilter(preview) {
|
||
var methodFilter = qs('openapi-import-method-filter');
|
||
var all = document.createElement('option');
|
||
var methods = Array.from(new Set((preview.groups || []).flatMap(function(group) {
|
||
return (group.operations || []).map(function(operation) {
|
||
return operation.method;
|
||
});
|
||
}))).sort();
|
||
|
||
methodFilter.replaceChildren();
|
||
all.value = '';
|
||
all.textContent = tKey('openapi.method.all');
|
||
methodFilter.appendChild(all);
|
||
|
||
methods.forEach(function(method) {
|
||
var option = document.createElement('option');
|
||
option.value = method;
|
||
option.textContent = method;
|
||
methodFilter.appendChild(option);
|
||
});
|
||
}
|
||
|
||
function renderPreview(response) {
|
||
var preview = response.preview;
|
||
var count = (preview.groups || []).reduce(function(sum, group) {
|
||
return sum + (group.operations || []).length;
|
||
}, 0);
|
||
var source = qs('openapi-import-source');
|
||
var groupsNode = qs('openapi-import-groups');
|
||
|
||
state.jobId = response.job_id;
|
||
state.preview = preview;
|
||
state.existingOperations = [];
|
||
state.operationsReady = false;
|
||
state.decisions = Object.create(null);
|
||
importOperations().forEach(function(operation) { decisionFor(operation.key); });
|
||
state.filterQuery = '';
|
||
state.filterMethod = '';
|
||
qs('openapi-import-preview-panel').hidden = false;
|
||
qs('openapi-import-result').hidden = true;
|
||
qs('openapi-import-result').replaceChildren();
|
||
source.textContent = tfKey('openapi.source.summary', {
|
||
name: boundedFileName(state.file),
|
||
size: formatSize(state.file.size),
|
||
count: count,
|
||
});
|
||
qs('openapi-import-search').value = '';
|
||
populateServers(preview);
|
||
populateMethodFilter(preview);
|
||
groupsNode.replaceChildren();
|
||
|
||
if (preview.findings && preview.findings.length) {
|
||
var documentFindings = document.createElement('div');
|
||
documentFindings.className = 'openapi-import-document-findings';
|
||
documentFindings.innerHTML = preview.findings.map(renderFinding).join('');
|
||
groupsNode.appendChild(documentFindings);
|
||
}
|
||
|
||
(preview.groups || []).forEach(function(group) {
|
||
var groupNode = document.createElement('section');
|
||
var header = document.createElement('div');
|
||
|
||
groupNode.className = 'openapi-import-group';
|
||
header.className = 'openapi-import-group-header';
|
||
header.innerHTML = '<span>' + escapeHtml(group.title) + ' · ' + group.operations.length + '</span>'
|
||
+ '<span class="openapi-import-group-count" data-openapi-group-count></span>'
|
||
+ '<label class="openapi-import-group-toggle"><input type="checkbox" data-openapi-group checked> '
|
||
+ escapeHtml(tKey('openapi.group.select'))
|
||
+ '</label>';
|
||
groupNode.appendChild(header);
|
||
|
||
group.operations.forEach(function(operation) {
|
||
var row = document.createElement('div');
|
||
var selectionLabel = document.createElement('label');
|
||
|
||
row.className = 'openapi-import-operation';
|
||
selectionLabel.className = 'openapi-import-operation-selection';
|
||
row.dataset.openapiMethod = operation.method;
|
||
row.dataset.openapiSearch = [
|
||
group.title,
|
||
operation.key,
|
||
operation.suggested_name,
|
||
operation.suggested_display_name,
|
||
operation.path,
|
||
operation.method,
|
||
].join(' ');
|
||
selectionLabel.innerHTML = '<input type="checkbox" data-openapi-operation value="' + escapeHtml(operation.key) + '" checked>'
|
||
+ '<div><div class="openapi-import-operation-title">' + escapeHtml(operation.suggested_display_name) + '</div>'
|
||
+ '<div class="openapi-import-operation-meta"><code>' + escapeHtml(operation.suggested_name) + '</code> · '
|
||
+ escapeHtml(operation.path) + ' · '
|
||
+ escapeHtml(tfKey('openapi.operation.fields', { input: operation.input_fields, output: operation.output_fields }))
|
||
+ '</div></div><span class="openapi-import-method">' + escapeHtml(operation.method) + '</span>';
|
||
row.appendChild(selectionLabel);
|
||
row.appendChild(renderOperationMappingPreview(operation));
|
||
|
||
if (operation.findings && operation.findings.length) {
|
||
var findings = document.createElement('div');
|
||
findings.className = 'openapi-import-findings';
|
||
findings.innerHTML = operation.findings.map(renderFinding).join('');
|
||
row.appendChild(findings);
|
||
}
|
||
|
||
renderDecisionControls(operation, row);
|
||
groupNode.appendChild(row);
|
||
});
|
||
|
||
groupNode.querySelector('[data-openapi-group]').addEventListener('change', function(event) {
|
||
groupNode.querySelectorAll('.openapi-import-operation').forEach(function(row) {
|
||
var input = row.querySelector('[data-openapi-operation]');
|
||
if (!row.hidden && input) input.checked = event.target.checked;
|
||
});
|
||
updateSelection();
|
||
});
|
||
groupsNode.appendChild(groupNode);
|
||
});
|
||
|
||
groupsNode.querySelectorAll('[data-openapi-operation]').forEach(function(input) {
|
||
input.addEventListener('change', updateSelection);
|
||
});
|
||
applyFilters();
|
||
}
|
||
|
||
function validateFile(file) {
|
||
if (!file) return 'openapi.error.file_required';
|
||
|
||
var name = String(file.name || '').toLowerCase();
|
||
var yaml = /\.(yaml|yml)$/.test(name);
|
||
var json = /\.json$/.test(name);
|
||
|
||
if (!yaml && !json) return 'openapi.error.file_type';
|
||
if (!file.size) return 'openapi.error.file_empty';
|
||
if (file.size > MAX_FILE_BYTES) return 'openapi.error.file_large';
|
||
|
||
var type = String(file.type || '').toLowerCase();
|
||
if (!type || type === 'application/octet-stream') return null;
|
||
|
||
var allowed = yaml
|
||
? ['application/yaml', 'application/x-yaml', 'text/yaml', 'text/x-yaml']
|
||
: ['application/json', 'application/openapi+json'];
|
||
return allowed.indexOf(type) >= 0 ? null : 'openapi.error.file_type';
|
||
}
|
||
|
||
function abort(controller) {
|
||
if (controller) controller.abort();
|
||
}
|
||
|
||
function clearPreview() {
|
||
state.jobId = null;
|
||
state.preview = null;
|
||
state.existingOperations = [];
|
||
state.operationsReady = false;
|
||
state.decisions = Object.create(null);
|
||
state.plan = null;
|
||
state.applyRequest = null;
|
||
state.applyMetadata = [];
|
||
state.applyResult = null;
|
||
state.applyOutcomeUnknown = false;
|
||
state.applyRefreshFailed = false;
|
||
state.filterQuery = '';
|
||
state.filterMethod = '';
|
||
qs('openapi-import-preview-panel').hidden = true;
|
||
qs('openapi-import-plan-confirmation').hidden = true;
|
||
qs('openapi-import-plan-counts').replaceChildren();
|
||
qs('openapi-import-plan-candidates').replaceChildren();
|
||
qs('openapi-import-versioning-consequences').hidden = true;
|
||
qs('openapi-import-plan-blocked-help').hidden = true;
|
||
qs('openapi-import-groups').replaceChildren();
|
||
qs('openapi-import-result').hidden = true;
|
||
qs('openapi-import-result').replaceChildren();
|
||
updateSelection();
|
||
}
|
||
|
||
function clearServerSelection() {
|
||
qs('openapi-import-server-custom').value = '';
|
||
qs('openapi-import-server').replaceChildren();
|
||
}
|
||
|
||
function invalidate(options) {
|
||
state.revision += 1;
|
||
abort(state.previewController);
|
||
abort(state.planController);
|
||
abort(state.applyController);
|
||
state.previewController = null;
|
||
state.planController = null;
|
||
state.applyController = null;
|
||
state.applyInFlight = false;
|
||
qs('openapi-import-preview').disabled = false;
|
||
qs('openapi-import-create').disabled = false;
|
||
qs('openapi-import-plan-apply').disabled = false;
|
||
qs('openapi-import-plan-back').disabled = false;
|
||
qs('openapi-import-file-select').disabled = false;
|
||
qs('openapi-import-reset').disabled = false;
|
||
qs('openapi-import-cancel').hidden = true;
|
||
clearPreview();
|
||
|
||
if (options && options.clearFile) {
|
||
state.file = null;
|
||
qs('openapi-import-file').value = '';
|
||
renderFileName();
|
||
}
|
||
}
|
||
|
||
function showRetry(show) {
|
||
qs('openapi-import-retry').hidden = !show;
|
||
}
|
||
|
||
function lockApplyInputs(locked) {
|
||
qs('openapi-import-create').disabled = locked;
|
||
qs('openapi-import-preview').disabled = locked;
|
||
qs('openapi-import-file-select').disabled = locked;
|
||
qs('openapi-import-reset').disabled = locked;
|
||
qs('openapi-import-plan-apply').disabled = locked;
|
||
qs('openapi-import-plan-back').disabled = locked;
|
||
qs('openapi-import-server').disabled = locked;
|
||
qs('openapi-import-server-custom').disabled = locked;
|
||
qs('openapi-import-search').disabled = locked;
|
||
qs('openapi-import-method-filter').disabled = locked;
|
||
qs('openapi-import-select-visible').disabled = locked;
|
||
qs('openapi-import-clear-visible').disabled = locked;
|
||
document.querySelectorAll('[data-openapi-operation], [data-openapi-group]').forEach(function(input) {
|
||
input.disabled = locked;
|
||
});
|
||
document.querySelectorAll('.openapi-import-decision-controls select, .openapi-import-decision-controls input').forEach(function(input) {
|
||
input.disabled = locked;
|
||
});
|
||
}
|
||
|
||
function lockPlanEditing(locked) {
|
||
qs('openapi-import-create').disabled = locked;
|
||
qs('openapi-import-preview').disabled = locked;
|
||
qs('openapi-import-file-select').disabled = locked;
|
||
qs('openapi-import-reset').disabled = locked;
|
||
qs('openapi-import-server').disabled = locked;
|
||
qs('openapi-import-server-custom').disabled = locked;
|
||
qs('openapi-import-search').disabled = locked;
|
||
qs('openapi-import-method-filter').disabled = locked;
|
||
qs('openapi-import-select-visible').disabled = locked;
|
||
qs('openapi-import-clear-visible').disabled = locked;
|
||
document.querySelectorAll('[data-openapi-operation], [data-openapi-group]').forEach(function(input) {
|
||
input.disabled = locked;
|
||
});
|
||
document.querySelectorAll('.openapi-import-decision-controls select, .openapi-import-decision-controls input').forEach(function(input) {
|
||
input.disabled = locked;
|
||
});
|
||
}
|
||
|
||
function markApplyOutcomeUnknown(options) {
|
||
if (!state.applyRequest) return false;
|
||
|
||
abort(state.applyController);
|
||
state.applyController = null;
|
||
state.applyInFlight = false;
|
||
state.applyOutcomeUnknown = true;
|
||
persistApplyReplay(state.applyRequest);
|
||
// Until the same plan is replayed, starting another import could hide an
|
||
// already committed server outcome and lead to duplicate drafts.
|
||
lockApplyInputs(true);
|
||
qs('openapi-import-cancel').hidden = true;
|
||
|
||
if (!options || options.render !== false) {
|
||
showRetry(true);
|
||
setStatus(tKey('openapi.plan.retry_unknown'), true, true);
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
function cancelCurrent() {
|
||
if (state.applyInFlight || state.applyController) {
|
||
markApplyOutcomeUnknown();
|
||
return;
|
||
}
|
||
if (state.planController) {
|
||
abort(state.planController);
|
||
state.planController = null;
|
||
state.revision += 1;
|
||
lockPlanEditing(false);
|
||
qs('openapi-import-cancel').hidden = true;
|
||
showRetry(false);
|
||
setStatus(tKey('openapi.status.cancelled'));
|
||
return;
|
||
}
|
||
if (!state.previewController) return;
|
||
|
||
invalidate();
|
||
showRetry(!!state.file);
|
||
setStatus(tKey('openapi.status.cancelled'));
|
||
}
|
||
|
||
function errorStatus(error, fallback) {
|
||
var known = {
|
||
'openapi_upload.missing_file': 'openapi.error.file_required',
|
||
'openapi_upload.invalid_media_type': 'openapi.error.file_type',
|
||
'openapi_upload.empty_file': 'openapi.error.file_empty',
|
||
'openapi_upload.file_too_large': 'openapi.error.file_large',
|
||
'openapi_upload.no_methods': 'openapi.error.no_methods',
|
||
'openapi_upload.malformed_multipart': 'openapi.error.malformed_multipart',
|
||
'openapi_upload.invalid_utf8': 'openapi.error.invalid_utf8',
|
||
'openapi_upload.invalid_document': 'openapi.error.invalid_document',
|
||
'openapi_upload.parser_unavailable': 'openapi.error.parser_unavailable',
|
||
'openapi_upload.storage_unavailable': 'openapi.error.storage_unavailable',
|
||
'openapi_upload.source_integrity': 'openapi.error.source_integrity',
|
||
'openapi_upload.source_unavailable': 'openapi.error.source_unavailable',
|
||
};
|
||
var message = tKey(known[error && error.code] || fallback);
|
||
var identifiers = [];
|
||
|
||
if (error && error.requestId) {
|
||
identifiers.push(tfKey('openapi.correlation.request_id', { id: error.requestId }));
|
||
}
|
||
if (error && error.traceId) {
|
||
identifiers.push(tfKey('openapi.correlation.trace_id', { id: error.traceId }));
|
||
}
|
||
|
||
return identifiers.length ? message + ' ' + identifiers.join(' · ') : message;
|
||
}
|
||
|
||
async function preview() {
|
||
var localError = validateFile(state.file);
|
||
if (localError) {
|
||
setStatus(tKey(localError), true, true);
|
||
showRetry(false);
|
||
return;
|
||
}
|
||
if (!state.workspaceId) {
|
||
setStatus(tKey('openapi.error.workspace'), true, true);
|
||
return;
|
||
}
|
||
|
||
invalidate();
|
||
var revision = state.revision;
|
||
var workspaceId = state.workspaceId;
|
||
var language = locale();
|
||
var controller = new AbortController();
|
||
|
||
state.previewController = controller;
|
||
qs('openapi-import-preview').disabled = true;
|
||
qs('openapi-import-cancel').hidden = false;
|
||
showRetry(false);
|
||
setStatus(tKey('openapi.status.previewing'));
|
||
|
||
try {
|
||
var response = await window.CrankApi.previewOpenApiImport(workspaceId, state.file, { signal: controller.signal });
|
||
if (!isCurrent(revision, workspaceId, language)) return;
|
||
|
||
renderPreview(response);
|
||
qs('openapi-import-create').disabled = true;
|
||
setStatus(tKey('openapi.status.loading_operations'));
|
||
var operationResponse = await window.CrankApi.listOperations(workspaceId);
|
||
if (!isCurrent(revision, workspaceId, language)) return;
|
||
if (!operationResponse || !Array.isArray(operationResponse.items)) {
|
||
throw new Error('Backend returned an invalid operations list response');
|
||
}
|
||
state.existingOperations = operationResponse.items;
|
||
state.operationsReady = true;
|
||
importOperations().forEach(function(operation) {
|
||
var row = Array.from(document.querySelectorAll('.openapi-import-operation')).find(function(candidateRow) {
|
||
var input = candidateRow.querySelector('[data-openapi-operation]');
|
||
return input && input.value === operation.key;
|
||
});
|
||
if (row) renderDecisionControls(operation, row);
|
||
});
|
||
qs('openapi-import-create').disabled = false;
|
||
setStatus(tKey('openapi.status.preview_ready'));
|
||
} catch (error) {
|
||
if (!isCurrent(revision, workspaceId, language)) return;
|
||
if (error && error.name === 'AbortError') {
|
||
setStatus(tKey('openapi.status.cancelled'));
|
||
return;
|
||
}
|
||
|
||
clearPreview();
|
||
showRetry(true);
|
||
setStatus(errorStatus(error, 'openapi.error.preview'), true, true);
|
||
} finally {
|
||
if (isCurrent(revision, workspaceId, language)) {
|
||
state.previewController = null;
|
||
qs('openapi-import-preview').disabled = false;
|
||
qs('openapi-import-cancel').hidden = true;
|
||
}
|
||
}
|
||
}
|
||
|
||
function previewOperationForCreated(created) {
|
||
var groups = state.preview && state.preview.groups || [];
|
||
|
||
for (var groupIndex = 0; groupIndex < groups.length; groupIndex += 1) {
|
||
var operations = groups[groupIndex].operations || [];
|
||
for (var operationIndex = 0; operationIndex < operations.length; operationIndex += 1) {
|
||
if (created.operation_key && operations[operationIndex].key === created.operation_key) {
|
||
return operations[operationIndex];
|
||
}
|
||
}
|
||
}
|
||
|
||
// Older servers did not return operation_key. Keep result rendering useful
|
||
// during a rolling upgrade, but use the unambiguous key whenever it exists.
|
||
for (var fallbackGroupIndex = 0; fallbackGroupIndex < groups.length; fallbackGroupIndex += 1) {
|
||
var fallbackOperations = groups[fallbackGroupIndex].operations || [];
|
||
for (var fallbackOperationIndex = 0; fallbackOperationIndex < fallbackOperations.length; fallbackOperationIndex += 1) {
|
||
if (fallbackOperations[fallbackOperationIndex].suggested_name === created.name) {
|
||
return fallbackOperations[fallbackOperationIndex];
|
||
}
|
||
}
|
||
}
|
||
|
||
for (var metadataIndex = 0; metadataIndex < state.applyMetadata.length; metadataIndex += 1) {
|
||
if (created.operation_key && state.applyMetadata[metadataIndex].key === created.operation_key) {
|
||
return state.applyMetadata[metadataIndex];
|
||
}
|
||
}
|
||
|
||
return null;
|
||
}
|
||
|
||
function wizardHref(operationId) {
|
||
return ((window.CrankRoutes && window.CrankRoutes.wizard) || '/wizard/')
|
||
+ '?mode=edit&operationId=' + encodeURIComponent(operationId);
|
||
}
|
||
|
||
function appendFindingNodes(root, findings) {
|
||
if (!findings || !findings.length) {
|
||
var empty = document.createElement('span');
|
||
empty.className = 'openapi-import-result-ok';
|
||
empty.textContent = tKey('openapi.result.no_findings');
|
||
root.appendChild(empty);
|
||
return;
|
||
}
|
||
|
||
findings.slice(0, 4).forEach(function(finding) {
|
||
var wrapper = document.createElement('div');
|
||
wrapper.innerHTML = renderFinding(finding);
|
||
root.appendChild(wrapper.firstElementChild);
|
||
});
|
||
|
||
if (findings.length > 4) {
|
||
var more = document.createElement('span');
|
||
more.className = 'openapi-import-result-more';
|
||
more.textContent = tfKey('openapi.result.more', { count: findings.length - 4 });
|
||
root.appendChild(more);
|
||
}
|
||
}
|
||
|
||
function renderResult(response) {
|
||
var node = qs('openapi-import-result');
|
||
var title = document.createElement('strong');
|
||
|
||
node.replaceChildren();
|
||
title.textContent = tKey('openapi.result.title');
|
||
node.appendChild(title);
|
||
|
||
if (response.created && response.created.length) {
|
||
var primary = document.createElement('div');
|
||
var table = document.createElement('div');
|
||
|
||
primary.className = 'openapi-import-primary-result';
|
||
primary.innerHTML = '<a class="btn-primary" href="' + wizardHref(response.created[0].operation_id) + '">'
|
||
+ escapeHtml(tKey('openapi.result.open_first'))
|
||
+ '</a>';
|
||
node.appendChild(primary);
|
||
|
||
table.className = 'openapi-import-result-table';
|
||
table.setAttribute('role', 'table');
|
||
table.innerHTML = '<div class="openapi-import-result-row openapi-import-result-head" role="row">'
|
||
+ '<div role="columnheader">' + escapeHtml(tKey('openapi.result.draft')) + '</div>'
|
||
+ '<div role="columnheader">' + escapeHtml(tKey('openapi.result.findings')) + '</div>'
|
||
+ '<div role="columnheader">' + escapeHtml(tKey('openapi.result.action')) + '</div>'
|
||
+ '</div>';
|
||
|
||
response.created.forEach(function(operation) {
|
||
var previewOperation = previewOperationForCreated(operation);
|
||
var row = document.createElement('div');
|
||
var nameCell = document.createElement('div');
|
||
var name = document.createElement('div');
|
||
var meta = document.createElement('div');
|
||
var findingsCell = document.createElement('div');
|
||
var actionCell = document.createElement('div');
|
||
var action = document.createElement('a');
|
||
|
||
row.className = 'openapi-import-result-row';
|
||
row.setAttribute('role', 'row');
|
||
nameCell.setAttribute('role', 'cell');
|
||
name.className = 'openapi-import-result-name';
|
||
name.textContent = operation.name;
|
||
meta.className = 'openapi-import-result-meta';
|
||
meta.textContent = previewOperation
|
||
? previewOperation.method + ' ' + previewOperation.path + ' · v' + operation.version
|
||
: 'v' + operation.version;
|
||
nameCell.append(name, meta);
|
||
findingsCell.className = 'openapi-import-result-findings';
|
||
findingsCell.setAttribute('role', 'cell');
|
||
appendFindingNodes(findingsCell, previewOperation && previewOperation.findings);
|
||
actionCell.setAttribute('role', 'cell');
|
||
action.className = 'btn-secondary openapi-import-result-action';
|
||
action.href = wizardHref(operation.operation_id);
|
||
action.textContent = previewOperation && previewOperation.findings && previewOperation.findings.length
|
||
? tKey('openapi.result.fix')
|
||
: tKey('openapi.result.open');
|
||
actionCell.appendChild(action);
|
||
row.append(nameCell, findingsCell, actionCell);
|
||
table.appendChild(row);
|
||
});
|
||
|
||
node.appendChild(table);
|
||
}
|
||
|
||
if (response.skipped && response.skipped.length) {
|
||
var skippedNode = document.createElement('div');
|
||
skippedNode.className = 'openapi-import-result-skipped';
|
||
skippedNode.textContent = tKey('openapi.result.skipped') + ': ' + response.skipped.map(function(item) {
|
||
return (item.name || item.operation_key || tKey('openapi.result.unnamed')) + ' — '
|
||
+ findingMessage({ code: item.code || item.reason_code || item.reason });
|
||
}).join('; ');
|
||
node.appendChild(skippedNode);
|
||
}
|
||
|
||
if (response.findings && response.findings.length) {
|
||
var findings = document.createElement('div');
|
||
findings.className = 'openapi-import-result-findings';
|
||
findings.innerHTML = response.findings.map(renderFinding).join('');
|
||
node.appendChild(findings);
|
||
}
|
||
|
||
node.hidden = false;
|
||
}
|
||
|
||
function createdStatus(response) {
|
||
if (response && response.counts) {
|
||
return tfKey('openapi.plan.summary', {
|
||
applied: (Number(response.counts.created) || 0)
|
||
+ (Number(response.counts.versioned) || 0)
|
||
+ (Number(response.counts.renamed) || 0),
|
||
skipped: Number(response.counts.skipped) || 0,
|
||
excluded: Number(response.counts.excluded) || 0,
|
||
rejected: Number(response.counts.rejected) || 0,
|
||
});
|
||
}
|
||
return tfKey('openapi.status.created', {
|
||
created: (response.created || []).length,
|
||
skipped: (response.skipped || []).length,
|
||
});
|
||
}
|
||
|
||
function planActionLabel(candidate) {
|
||
if (candidate.state === 'excluded') return tKey('openapi.plan.action.excluded');
|
||
if (candidate.state === 'blocked') return tKey('openapi.plan.action.blocked');
|
||
var action = String(candidate.action || 'create');
|
||
var key = 'openapi.plan.action.' + action;
|
||
return tKey(key) === key ? tKey('openapi.plan.action.create') : tKey(key);
|
||
}
|
||
|
||
function renderImportPlan(plan) {
|
||
var countsNode = qs('openapi-import-plan-counts');
|
||
var candidatesNode = qs('openapi-import-plan-candidates');
|
||
var versioningNode = qs('openapi-import-versioning-consequences');
|
||
var counts = plan.counts || {};
|
||
var hasBlocked = (Number(counts.blocked) || 0) > 0;
|
||
var countSpecs = [
|
||
['selected', 'openapi.plan.selected'],
|
||
['excluded', 'openapi.plan.excluded'],
|
||
['actionable', 'openapi.plan.actionable'],
|
||
['blocked', 'openapi.plan.blocked'],
|
||
];
|
||
|
||
countsNode.replaceChildren();
|
||
candidatesNode.replaceChildren();
|
||
countSpecs.forEach(function(spec) {
|
||
var item = document.createElement('span');
|
||
item.className = 'openapi-import-plan-count';
|
||
item.textContent = tfKey(spec[1], { count: Number(counts[spec[0]]) || 0 });
|
||
countsNode.appendChild(item);
|
||
});
|
||
|
||
var hasNewVersion = false;
|
||
(Array.isArray(plan.candidates) ? plan.candidates : []).forEach(function(candidate) {
|
||
var item = document.createElement('article');
|
||
var title = document.createElement('strong');
|
||
var key = document.createElement('code');
|
||
var action = document.createElement('p');
|
||
item.className = 'openapi-import-plan-candidate';
|
||
item.dataset.state = String(candidate.state || 'blocked');
|
||
title.textContent = String(candidate.name || candidate.key || tKey('openapi.result.unnamed'));
|
||
key.textContent = String(candidate.key || '');
|
||
action.textContent = planActionLabel(candidate);
|
||
item.append(title, key, action);
|
||
if (candidate.target_operation_id) {
|
||
var target = document.createElement('p');
|
||
target.textContent = tKey('openapi.plan.exact_target') + ': ' + candidate.target_operation_id;
|
||
item.appendChild(target);
|
||
}
|
||
if (candidate.confirmed_name) {
|
||
var confirmedName = document.createElement('p');
|
||
confirmedName.textContent = tKey('openapi.plan.confirmed_name') + ': ' + candidate.confirmed_name;
|
||
item.appendChild(confirmedName);
|
||
}
|
||
if (candidate.action === 'new_version' && candidate.state !== 'blocked' && candidate.state !== 'excluded') {
|
||
hasNewVersion = true;
|
||
}
|
||
if (candidate.reason) {
|
||
var reason = document.createElement('p');
|
||
reason.className = 'openapi-import-plan-reason';
|
||
reason.textContent = findingMessage({ code: candidate.reason });
|
||
item.appendChild(reason);
|
||
}
|
||
candidatesNode.appendChild(item);
|
||
});
|
||
|
||
versioningNode.textContent = tKey('openapi.plan.versioning_new');
|
||
versioningNode.hidden = !hasNewVersion;
|
||
qs('openapi-import-plan-confirmation').hidden = false;
|
||
qs('openapi-import-plan-blocked-help').hidden = !hasBlocked;
|
||
qs('openapi-import-result').hidden = true;
|
||
qs('openapi-import-plan-apply').disabled = hasBlocked;
|
||
qs('openapi-import-plan-back').textContent = tKey(hasBlocked ? 'openapi.plan.back_fix' : 'openapi.plan.back');
|
||
lockPlanEditing(true);
|
||
}
|
||
|
||
function reportOutcomeLabel(outcome) {
|
||
var value = String(outcome || 'rejected');
|
||
var key = 'openapi.plan.outcome.' + value;
|
||
return tKey(key) === key ? tKey('openapi.plan.outcome.rejected') : tKey(key);
|
||
}
|
||
|
||
function renderImportPlanReport(report) {
|
||
var node = qs('openapi-import-result');
|
||
var title = document.createElement('strong');
|
||
node.replaceChildren();
|
||
title.textContent = tKey('openapi.plan.result_title');
|
||
node.appendChild(title);
|
||
|
||
var counts = report.counts || {};
|
||
var applied = (Number(counts.created) || 0)
|
||
+ (Number(counts.versioned) || 0)
|
||
+ (Number(counts.renamed) || 0);
|
||
var summary = document.createElement('p');
|
||
summary.className = 'openapi-import-plan-summary';
|
||
summary.textContent = tfKey('openapi.plan.summary', {
|
||
applied: applied,
|
||
skipped: Number(counts.skipped) || 0,
|
||
excluded: Number(counts.excluded) || 0,
|
||
rejected: Number(counts.rejected) || 0,
|
||
});
|
||
node.appendChild(summary);
|
||
|
||
var outcomes = Array.isArray(report.outcomes) ? report.outcomes : [];
|
||
if (outcomes.length) {
|
||
var list = document.createElement('div');
|
||
list.className = 'openapi-import-plan-outcomes';
|
||
outcomes.forEach(function(outcome) {
|
||
var item = document.createElement('article');
|
||
var heading = document.createElement('strong');
|
||
var key = document.createElement('code');
|
||
var detail = document.createElement('p');
|
||
var outcomeStatus = outcome.status || outcome.outcome || 'rejected';
|
||
item.className = 'openapi-import-plan-outcome';
|
||
item.dataset.outcome = String(outcomeStatus);
|
||
heading.textContent = String(outcome.name || outcome.key || tKey('openapi.result.unnamed'));
|
||
key.textContent = String(outcome.key || '');
|
||
detail.textContent = reportOutcomeLabel(outcomeStatus);
|
||
if (Number.isInteger(outcome.version)) {
|
||
detail.textContent += ' · v' + outcome.version;
|
||
}
|
||
item.append(heading, key, detail);
|
||
if (outcome.reason) {
|
||
var reason = document.createElement('p');
|
||
reason.className = 'openapi-import-plan-reason';
|
||
reason.textContent = findingMessage({ code: outcome.reason });
|
||
item.appendChild(reason);
|
||
}
|
||
list.appendChild(item);
|
||
});
|
||
node.appendChild(list);
|
||
}
|
||
|
||
node.hidden = false;
|
||
qs('openapi-import-plan-confirmation').hidden = true;
|
||
}
|
||
|
||
function recoveryCode(payload) {
|
||
var value = payload && payload.error && typeof payload.error === 'object'
|
||
? payload.error
|
||
: payload;
|
||
var context = value && value.context && typeof value.context === 'object'
|
||
? value.context
|
||
: value;
|
||
return String((context && context.recovery) || (payload && payload.recovery) || '');
|
||
}
|
||
|
||
function reportFromPayload(payload) {
|
||
if (!payload || typeof payload !== 'object') return null;
|
||
var errorContext = payload.error && payload.error.context;
|
||
var report = payload.report || payload.apply_report
|
||
|| (errorContext && (errorContext.report || errorContext.apply_report || errorContext))
|
||
|| payload;
|
||
return report && Array.isArray(report.outcomes) ? report : null;
|
||
}
|
||
|
||
async function notifyImported(revision, workspaceId, language) {
|
||
if (typeof state.onImported !== 'function') return;
|
||
|
||
try {
|
||
await state.onImported();
|
||
} catch (_error) {
|
||
state.applyRefreshFailed = true;
|
||
if (isCurrent(revision, workspaceId, language) && state.applyResult) {
|
||
setStatus(createdStatus(state.applyResult) + ' ' + tKey('openapi.status.refresh_failed'), false, true);
|
||
}
|
||
}
|
||
}
|
||
|
||
async function submitApply(request) {
|
||
if (state.applyInFlight) return;
|
||
|
||
var revision = state.revision;
|
||
var workspaceId = request.workspaceId;
|
||
var language = locale();
|
||
var controller = new AbortController();
|
||
|
||
state.applyController = controller;
|
||
state.applyInFlight = true;
|
||
state.applyOutcomeUnknown = false;
|
||
state.applyRefreshFailed = false;
|
||
lockApplyInputs(true);
|
||
qs('openapi-import-cancel').hidden = false;
|
||
showRetry(false);
|
||
setStatus(tKey('openapi.status.applying'));
|
||
|
||
try {
|
||
var response = await window.CrankApi.applyOpenApiImportPlan(
|
||
workspaceId,
|
||
request.planReference,
|
||
{
|
||
plan_digest: request.planDigest,
|
||
idempotency_key: request.idempotencyKey,
|
||
},
|
||
{ signal: controller.signal }
|
||
);
|
||
// Abort is advisory: a superseded request can still deliver a response.
|
||
// Only the controller installed by this attempt may mutate UI authority.
|
||
if (state.applyController !== controller) return;
|
||
state.applyOutcomeUnknown = false;
|
||
clearApplyReplay();
|
||
state.applyController = null;
|
||
state.applyInFlight = false;
|
||
lockApplyInputs(false);
|
||
qs('openapi-import-cancel').hidden = true;
|
||
showRetry(false);
|
||
if (!isSameContext(revision, workspaceId, language)) {
|
||
// The original workspace job is now resolved. Do not render its result
|
||
// into another workspace/language context.
|
||
state.applyResult = null;
|
||
state.applyRequest = null;
|
||
return;
|
||
}
|
||
state.applyResult = response;
|
||
state.applyRequest = null;
|
||
state.plan = null;
|
||
if (isCurrent(revision, workspaceId, language)) {
|
||
renderImportPlanReport(response);
|
||
if (response.recovery === 'repreview_required') {
|
||
setStatus(tKey('openapi.plan.repreview'), true, true);
|
||
showRetry(true);
|
||
} else if (response.status === 'rejected'
|
||
|| response.recovery === 'confirm_skip_rename_or_new_version') {
|
||
setStatus(tKey('openapi.plan.resolve_conflict'), true, true);
|
||
showRetry(true);
|
||
} else {
|
||
setStatus(tKey('openapi.status.applied'));
|
||
}
|
||
}
|
||
await notifyImported(revision, workspaceId, language);
|
||
} catch (error) {
|
||
// A cancelled attempt may settle after an idempotent retry has already
|
||
// installed a new controller. It must not overwrite the newer state.
|
||
if (state.applyController !== controller) return;
|
||
if (error && error.name === 'AbortError') {
|
||
state.applyOutcomeUnknown = true;
|
||
persistApplyReplay(state.applyRequest);
|
||
lockApplyInputs(true);
|
||
showRetry(true);
|
||
if (!qs('openapi-import-modal').hidden) {
|
||
setStatus(tKey('openapi.plan.retry_unknown'), true, true);
|
||
}
|
||
return;
|
||
}
|
||
|
||
if (Number.isInteger(error && error.status)
|
||
&& error.status >= 400 && error.status < 500 && error.status !== 408) {
|
||
state.applyOutcomeUnknown = false;
|
||
state.applyRequest = null;
|
||
clearApplyReplay();
|
||
showRetry(true);
|
||
var report = reportFromPayload(error.payload);
|
||
if (report && isCurrent(revision, workspaceId, language)) {
|
||
state.applyResult = report;
|
||
renderImportPlanReport(report);
|
||
}
|
||
var recovery = recoveryCode(error.payload);
|
||
state.plan = null;
|
||
qs('openapi-import-plan-confirmation').hidden = true;
|
||
lockPlanEditing(false);
|
||
if (!qs('openapi-import-modal').hidden) {
|
||
if (recovery === 'repreview_required') {
|
||
setStatus(tKey('openapi.plan.repreview'), true, true);
|
||
} else if (recovery === 'confirm_skip_rename_or_new_version') {
|
||
setStatus(tKey('openapi.plan.resolve_conflict'), true, true);
|
||
} else {
|
||
setStatus(errorStatus(error, 'openapi.error.apply'), true, true);
|
||
}
|
||
}
|
||
return;
|
||
}
|
||
|
||
// A browser/network failure is not proof that the server rolled the
|
||
// transaction back. Replaying this exact plan is idempotent server-side.
|
||
state.applyOutcomeUnknown = true;
|
||
persistApplyReplay(state.applyRequest);
|
||
lockApplyInputs(true);
|
||
showRetry(true);
|
||
if (!qs('openapi-import-modal').hidden) {
|
||
setStatus(errorStatus(error, 'openapi.error.apply') + ' ' + tKey('openapi.plan.retry_unknown'), true, true);
|
||
}
|
||
} finally {
|
||
if (state.applyController === controller) {
|
||
state.applyController = null;
|
||
state.applyInFlight = false;
|
||
lockApplyInputs(state.applyOutcomeUnknown);
|
||
qs('openapi-import-cancel').hidden = true;
|
||
}
|
||
}
|
||
}
|
||
|
||
async function createImportPlan() {
|
||
if (state.applyInFlight || state.planController) return;
|
||
|
||
var keys = selectedKeys();
|
||
if (!keys.length) {
|
||
setStatus(tKey('openapi.error.selection'), true, true);
|
||
return;
|
||
}
|
||
if (keys.length > 512 || importOperations().length - keys.length > 512) {
|
||
setStatus(tKey('openapi.error.plan_too_large'), true, true);
|
||
return;
|
||
}
|
||
if (!state.jobId || !state.preview) {
|
||
setStatus(tKey('openapi.error.preview_required'), true, true);
|
||
return;
|
||
}
|
||
|
||
var serverUrl = (qs('openapi-import-server-custom').value || qs('openapi-import-server').value || '').trim();
|
||
if (!serverUrl) {
|
||
setStatus(tKey('openapi.error.server'), true, true);
|
||
return;
|
||
}
|
||
|
||
if (!state.workspaceId) {
|
||
setStatus(tKey('openapi.error.workspace'), true, true);
|
||
return;
|
||
}
|
||
|
||
if (!state.operationsReady) {
|
||
setStatus(tKey('openapi.error.operations_unavailable'), true, true);
|
||
return;
|
||
}
|
||
|
||
var selectedSet = new Set(keys);
|
||
var decisions = [];
|
||
var invalidDecision = null;
|
||
importOperations().forEach(function(operation) {
|
||
if (!selectedSet.has(operation.key) || invalidDecision) return;
|
||
var decision = decisionFor(operation.key);
|
||
var output = { operation_key: operation.key, action: decision.action };
|
||
if (decision.action === 'skip' || decision.action === 'new_version') {
|
||
var allowedTargets = matchingOperations(operation).filter(function(existing) {
|
||
return decision.action !== 'new_version'
|
||
|| (existing.protocol === 'rest' && existing.status !== 'archived');
|
||
});
|
||
if (!allowedTargets.some(function(existing) { return existing.id === decision.targetOperationId; })) {
|
||
invalidDecision = 'openapi.error.decision_target';
|
||
return;
|
||
}
|
||
output.target_operation_id = decision.targetOperationId;
|
||
} else if (decision.action === 'rename') {
|
||
if (!decision.confirmedName || !decision.confirmedName.trim()) {
|
||
invalidDecision = 'openapi.error.confirmed_name';
|
||
return;
|
||
}
|
||
output.confirmed_name = decision.confirmedName;
|
||
} else if (decision.action !== 'create') {
|
||
invalidDecision = 'openapi.error.decision_action';
|
||
return;
|
||
}
|
||
if (decision.action !== 'create') decisions.push(output);
|
||
});
|
||
if (invalidDecision) {
|
||
setStatus(tKey(invalidDecision), true, true);
|
||
return;
|
||
}
|
||
|
||
var total = (state.preview.groups || []).reduce(function(count, group) {
|
||
return count + (group.operations || []).length;
|
||
}, 0);
|
||
var selectionMode = keys.length === total ? 'full' : 'partial';
|
||
var payload = {
|
||
selection_mode: selectionMode,
|
||
selected_operation_keys: selectionMode === 'full' ? [] : keys,
|
||
server_url: serverUrl,
|
||
decisions: decisions,
|
||
};
|
||
var revision = state.revision;
|
||
var workspaceId = state.workspaceId;
|
||
var language = locale();
|
||
var controller = new AbortController();
|
||
state.planController = controller;
|
||
state.plan = null;
|
||
lockPlanEditing(true);
|
||
qs('openapi-import-cancel').hidden = false;
|
||
qs('openapi-import-plan-confirmation').hidden = true;
|
||
showRetry(false);
|
||
setStatus(tKey('openapi.status.planning'));
|
||
|
||
try {
|
||
var plan = await window.CrankApi.createOpenApiImportPlan(
|
||
workspaceId,
|
||
state.jobId,
|
||
payload,
|
||
{ signal: controller.signal }
|
||
);
|
||
if (state.planController !== controller) return;
|
||
if (!isCurrent(revision, workspaceId, language)) return;
|
||
if (!plan || typeof plan.plan_reference !== 'string'
|
||
|| !/^[a-f0-9]{64}$/.test(String(plan.plan_digest || ''))
|
||
|| !plan.counts || !Array.isArray(plan.candidates)) {
|
||
throw new Error('Backend returned an invalid ImportPlan response');
|
||
}
|
||
state.plan = plan;
|
||
renderImportPlan(plan);
|
||
setStatus(tKey('openapi.status.plan_ready'));
|
||
} catch (error) {
|
||
if (state.planController !== controller) return;
|
||
if (error && error.name === 'AbortError') {
|
||
setStatus(tKey('openapi.status.cancelled'));
|
||
return;
|
||
}
|
||
setStatus(errorStatus(error, 'openapi.error.plan'), true, true);
|
||
showRetry(true);
|
||
} finally {
|
||
if (state.planController === controller) {
|
||
state.planController = null;
|
||
lockPlanEditing(!!state.plan);
|
||
qs('openapi-import-cancel').hidden = true;
|
||
}
|
||
}
|
||
}
|
||
|
||
function newIdempotencyKey() {
|
||
if (window.crypto && typeof window.crypto.randomUUID === 'function') {
|
||
return 'openapi:' + window.crypto.randomUUID();
|
||
}
|
||
return 'openapi:' + Date.now().toString(36) + ':' + Math.random().toString(36).slice(2);
|
||
}
|
||
|
||
async function applyImportPlan() {
|
||
if (state.applyInFlight || !state.plan || state.applyOutcomeUnknown) return;
|
||
var request = {
|
||
workspaceId: state.workspaceId,
|
||
planReference: state.plan.plan_reference,
|
||
planDigest: state.plan.plan_digest,
|
||
idempotencyKey: newIdempotencyKey(),
|
||
};
|
||
if (!validApplyReplay(request)) {
|
||
setStatus(tKey('openapi.error.apply'), true, true);
|
||
return;
|
||
}
|
||
state.applyRequest = request;
|
||
persistApplyReplay(request);
|
||
await submitApply(request);
|
||
}
|
||
|
||
function backToImportSelection() {
|
||
if (state.applyInFlight || state.applyOutcomeUnknown) return;
|
||
state.plan = null;
|
||
qs('openapi-import-plan-confirmation').hidden = true;
|
||
qs('openapi-import-plan-counts').replaceChildren();
|
||
qs('openapi-import-plan-candidates').replaceChildren();
|
||
qs('openapi-import-versioning-consequences').hidden = true;
|
||
qs('openapi-import-plan-blocked-help').hidden = true;
|
||
qs('openapi-import-plan-back').textContent = tKey('openapi.plan.back');
|
||
lockPlanEditing(false);
|
||
setStatus(tKey('openapi.status.preview_ready'));
|
||
}
|
||
|
||
function retryCurrent() {
|
||
if (state.applyOutcomeUnknown && state.applyRequest) {
|
||
return submitApply(state.applyRequest);
|
||
}
|
||
return preview();
|
||
}
|
||
|
||
function reset() {
|
||
invalidate({ clearFile: true });
|
||
showRetry(false);
|
||
setStatus('');
|
||
qs('openapi-import-server-custom').value = '';
|
||
}
|
||
|
||
function open(options) {
|
||
if (state.workspaceId && state.workspaceId !== options.workspaceId
|
||
&& !(state.applyOutcomeUnknown && state.applyRequest)) {
|
||
invalidate({ clearFile: true });
|
||
}
|
||
|
||
state.workspaceId = options.workspaceId;
|
||
state.onImported = options.onImported;
|
||
state.restoreFocus = document.activeElement;
|
||
qs('openapi-import-modal').hidden = false;
|
||
renderFileName();
|
||
if (state.applyResult) {
|
||
if (Array.isArray(state.applyResult.outcomes)) {
|
||
renderImportPlanReport(state.applyResult);
|
||
} else {
|
||
renderResult(state.applyResult);
|
||
}
|
||
if (state.applyResult.recovery === 'repreview_required') {
|
||
showRetry(true);
|
||
setStatus(tKey('openapi.plan.repreview'), true, true);
|
||
} else if (state.applyResult.status === 'rejected'
|
||
|| state.applyResult.recovery === 'confirm_skip_rename_or_new_version') {
|
||
showRetry(true);
|
||
setStatus(tKey('openapi.plan.resolve_conflict'), true, true);
|
||
} else {
|
||
setStatus(createdStatus(state.applyResult) + (state.applyRefreshFailed ? ' ' + tKey('openapi.status.refresh_failed') : ''));
|
||
}
|
||
} else if (state.applyOutcomeUnknown && state.applyRequest) {
|
||
lockApplyInputs(true);
|
||
showRetry(true);
|
||
setStatus(tKey('openapi.plan.retry_unknown'), true, true);
|
||
qs('openapi-import-retry').focus();
|
||
return;
|
||
}
|
||
qs('openapi-import-file-select').focus();
|
||
}
|
||
|
||
function close() {
|
||
if (state.applyInFlight || state.applyController) {
|
||
markApplyOutcomeUnknown({ render: false });
|
||
qs('openapi-import-modal').hidden = true;
|
||
if (state.restoreFocus && typeof state.restoreFocus.focus === 'function') {
|
||
state.restoreFocus.focus();
|
||
}
|
||
return;
|
||
}
|
||
if (state.applyOutcomeUnknown && state.applyRequest) {
|
||
persistApplyReplay(state.applyRequest);
|
||
qs('openapi-import-modal').hidden = true;
|
||
if (state.restoreFocus && typeof state.restoreFocus.focus === 'function') {
|
||
state.restoreFocus.focus();
|
||
}
|
||
return;
|
||
}
|
||
invalidate({ clearFile: true });
|
||
showRetry(false);
|
||
qs('openapi-import-modal').hidden = true;
|
||
|
||
if (state.restoreFocus && typeof state.restoreFocus.focus === 'function') {
|
||
state.restoreFocus.focus();
|
||
}
|
||
}
|
||
|
||
function selectFile(file) {
|
||
clearServerSelection();
|
||
invalidate();
|
||
state.file = file || null;
|
||
showRetry(false);
|
||
|
||
var localError = validateFile(state.file);
|
||
renderFileName();
|
||
|
||
if (localError) {
|
||
setStatus(tKey(localError), true, true);
|
||
} else if (state.file) {
|
||
setStatus(tKey('openapi.status.file_ready'));
|
||
}
|
||
}
|
||
|
||
document.addEventListener('DOMContentLoaded', function() {
|
||
if (!qs('openapi-import-modal')) return;
|
||
|
||
renderFileName();
|
||
|
||
qs('openapi-import-file-select').addEventListener('click', function(event) {
|
||
event.preventDefault();
|
||
qs('openapi-import-file').click();
|
||
});
|
||
qs('openapi-import-file').addEventListener('change', function(event) {
|
||
selectFile(event.target.files && event.target.files[0]);
|
||
});
|
||
qs('openapi-import-preview').addEventListener('click', preview);
|
||
qs('openapi-import-retry').addEventListener('click', retryCurrent);
|
||
qs('openapi-import-create').addEventListener('click', createImportPlan);
|
||
qs('openapi-import-plan-apply').addEventListener('click', applyImportPlan);
|
||
qs('openapi-import-plan-back').addEventListener('click', backToImportSelection);
|
||
qs('openapi-import-cancel').addEventListener('click', cancelCurrent);
|
||
qs('openapi-import-reset').addEventListener('click', reset);
|
||
qs('openapi-import-search').addEventListener('input', function(event) {
|
||
state.filterQuery = event.target.value.trim();
|
||
applyFilters();
|
||
});
|
||
qs('openapi-import-method-filter').addEventListener('change', function(event) {
|
||
state.filterMethod = event.target.value;
|
||
applyFilters();
|
||
});
|
||
qs('openapi-import-select-visible').addEventListener('click', function() {
|
||
setVisibleSelection(true);
|
||
});
|
||
qs('openapi-import-clear-visible').addEventListener('click', function() {
|
||
setVisibleSelection(false);
|
||
});
|
||
document.querySelectorAll('[data-openapi-close]').forEach(function(node) {
|
||
node.addEventListener('click', close);
|
||
});
|
||
document.addEventListener('keydown', function(event) {
|
||
var modal = qs('openapi-import-modal');
|
||
|
||
if (event.key === 'Escape' && !qs('openapi-import-modal').hidden) {
|
||
event.preventDefault();
|
||
close();
|
||
}
|
||
if (event.key !== 'Tab' || modal.hidden) return;
|
||
|
||
var focusable = Array.from(modal.querySelectorAll('button:not([disabled]):not([hidden]), input:not([disabled]), select:not([disabled]), a[href]'))
|
||
.filter(function(node) { return node.tabIndex >= 0 && !node.closest('[hidden]'); });
|
||
if (!focusable.length) return;
|
||
var first = focusable[0];
|
||
var last = focusable[focusable.length - 1];
|
||
|
||
if (event.shiftKey && (document.activeElement === first || !modal.contains(document.activeElement))) {
|
||
event.preventDefault();
|
||
last.focus();
|
||
} else if (!event.shiftKey && document.activeElement === last) {
|
||
event.preventDefault();
|
||
first.focus();
|
||
}
|
||
});
|
||
function invalidateForContext(options) {
|
||
if (!qs('openapi-import-modal').hidden) {
|
||
if (state.applyInFlight || state.applyController) {
|
||
markApplyOutcomeUnknown();
|
||
return;
|
||
}
|
||
if (state.applyOutcomeUnknown && state.applyRequest) {
|
||
showRetry(true);
|
||
setStatus(tKey('openapi.plan.retry_unknown'), true, true);
|
||
return;
|
||
}
|
||
invalidate(options);
|
||
renderFileName();
|
||
showRetry(!options || !options.clearFile ? !!state.file : false);
|
||
setStatus(tKey('openapi.status.context_changed'));
|
||
}
|
||
}
|
||
function handleLanguageChange() {
|
||
if (!qs('openapi-import-modal').hidden && state.plan && !state.applyInFlight && !state.applyOutcomeUnknown) {
|
||
renderImportPlan(state.plan);
|
||
setStatus(tKey('openapi.status.plan_ready'));
|
||
return;
|
||
}
|
||
invalidateForContext();
|
||
}
|
||
window.addEventListener('crank:langchange', handleLanguageChange);
|
||
window.addEventListener('crank:workspacechange', function(event) {
|
||
if (!qs('openapi-import-modal').hidden) {
|
||
state.workspaceId = event.detail && event.detail.id || null;
|
||
invalidateForContext({ clearFile: true });
|
||
}
|
||
});
|
||
window.addEventListener('storage', function(event) {
|
||
if (event.key === 'crank_lang') handleLanguageChange();
|
||
});
|
||
window.addEventListener('pagehide', function() {
|
||
if (state.applyInFlight || state.applyController) {
|
||
markApplyOutcomeUnknown({ render: false });
|
||
state.file = null;
|
||
qs('openapi-import-file').value = '';
|
||
renderFileName();
|
||
} else if (state.applyOutcomeUnknown && state.applyRequest) {
|
||
persistApplyReplay(state.applyRequest);
|
||
} else {
|
||
invalidate({ clearFile: true });
|
||
}
|
||
clearServerSelection();
|
||
showRetry(false);
|
||
setStatus('');
|
||
});
|
||
window.addEventListener('pageshow', function(event) {
|
||
if (!event.persisted || qs('openapi-import-modal').hidden) return;
|
||
|
||
if (state.applyOutcomeUnknown && state.applyRequest) {
|
||
lockApplyInputs(true);
|
||
showRetry(true);
|
||
setStatus(tKey('openapi.plan.retry_unknown'), true, true);
|
||
} else {
|
||
invalidateForContext({ clearFile: true });
|
||
}
|
||
});
|
||
});
|
||
|
||
window.CrankOpenApiImport = {
|
||
open: open,
|
||
close: close,
|
||
reset: reset,
|
||
};
|
||
}());
|