@falldownthesystem/devtool 0.4.1 → 0.6.1

package/src/config/setup.js

@@ -0,0 +1,113 @@
+import * as p from '@clack/prompts';
+import pc from 'picocolors';
+import {
+	types, label, listConnections, isDefault, saveConnection, validateName, resolveIndex, fieldProblem,
+} from './store.js';
+
+function answer(value) {
+	if (p.isCancel(value)) {
+		p.cancel('Setup cancelled.');
+		process.exit(0);
+	}
+	return (value ?? '').trim();
+}
+
+export function describe(connections, index) {
+	const connection = connections[index];
+	const { title } = types[connection.type];
+	const sameType = connections.filter((c) => c.type === connection.type).length;
+	const marker = sameType > 1 && isDefault(connections, index) ? ', default' : '';
+	return `${label(connection)} (${title}${marker})`;
+}
+
+async function chooseType() {
+	return answer(await p.select({
+		message: 'Connection type',
+		options: Object.entries(types).map(([value, { title }]) => ({ value, label: title })),
+	}));
+}
+
+// Service Desk Cloud often shares an Atlassian account with Confluence Cloud.
+async function reusableCredentials(connections) {
+	const sources = connections.filter((c) => c.type === 'confluence' && c.email && c.token);
+	if (!sources.length) return null;
+	const choice = answer(await p.select({
+		message: 'Service Desk credentials',
+		options: [
+			...sources.map((c) => ({ value: label(c), label: `Reuse email and token from Confluence connection "${label(c)}"` })),
+			{ value: '', label: 'Enter new credentials' },
+		],
+	}));
+	return sources.find((c) => label(c) === choice) ?? null;
+}
+
+async function promptConnection(type, existing = {}, index = -1) {
+	const connections = listConnections();
+	const connection = { type };
+	if (existing.default) connection.default = true;
+	if (types[type].note) p.note(types[type].note, types[type].title);
+
+	const unnamedTaken = connections.some((c, i) => i !== index && c.type === type && !c.name);
+	connection.name = answer(await p.text({
+		message: unnamedTaken ? 'Connection name' : 'Connection name (optional)',
+		placeholder: unnamedTaken ? 'work' : `leave empty to refer to it as "${type}"`,
+		initialValue: existing.name || '',
+		validate: (v) => validateName(connections, { type, name: (v ?? '').trim() }, index),
+	}));
+
+	const reused = type === 'serviceDesk' ? await reusableCredentials(connections) : null;
+
+	for (const [key, field] of Object.entries(types[type].fields)) {
+		if (reused && (key === 'email' || key === 'token')) {
+			connection[key] = reused[key];
+			continue;
+		}
+		const keep = field.secret && existing[key];
+		const message = keep ? `${field.message} (leave empty to keep the current one)` : field.message;
+		const validate = (v) => {
+			const value = (v ?? '').trim();
+			if (!value) return field.required && !keep ? 'Required' : undefined;
+			return fieldProblem(type, key, value);
+		};
+		const value = field.secret
+			? answer(await p.password({ message, validate }))
+			: answer(await p.text({ message, placeholder: field.placeholder, initialValue: existing[key] || '', validate }));
+		connection[key] = value || (keep ? existing[key] : '');
+	}
+
+	saveConnection(connection, index);
+	return connection;
+}
+
+export async function addConnection(type, name) {
+	p.intro(pc.cyan('Add a connection'));
+	const connection = await promptConnection(type || await chooseType(), { name });
+	p.outro(pc.green(`Saved connection "${label(connection)}"`));
+}
+
+export async function editConnection(ref) {
+	const index = resolveIndex(ref);
+	const existing = listConnections()[index];
+	p.intro(pc.cyan(`Edit connection "${label(existing)}"`));
+	const connection = await promptConnection(existing.type, existing, index);
+	p.outro(pc.green(`Saved connection "${label(connection)}"`));
+}
+
+export async function runSetup() {
+	p.intro(pc.cyan('DevTool Setup'));
+	for (;;) {
+		const connections = listConnections();
+		const choice = answer(await p.select({
+			message: connections.length ? 'Edit a connection, or add a new one' : 'No connections configured yet',
+			options: [
+				...connections.map((_, i) => ({ value: String(i), label: `Edit ${describe(connections, i)}` })),
+				{ value: 'add', label: 'Add a connection' },
+				{ value: 'done', label: 'Done' },
+			],
+		}));
+		if (choice === 'done') break;
+		if (choice === 'add') await promptConnection(await chooseType());
+		else await promptConnection(connections[choice].type, connections[choice], Number(choice));
+	}
+	p.outro(pc.green('Configuration saved!'));
+}

package/src/config/store.js

@@ -1,213 +1,249 @@
 import Conf from 'conf';
-import * as p from '@clack/prompts';
-import pc from 'picocolors';
 
-export const schema = {
+export function validateGraphId(value) {
+	return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value?.trim() || '')
+		? undefined
+		: 'Enter the ID as a UUID from the Entra application Overview page.';
+}
+
+export function validateGraphSite(value) {
+	if (!value?.trim()) return undefined;
+	try {
+		const url = new URL(value.trim());
+		if (url.protocol === 'https:' && url.hostname.endsWith('.sharepoint.com') && !url.username && !url.password && !url.port && !url.search && !url.hash) {
+			decodeURIComponent(url.pathname);
+			return undefined;
+		}
+	} catch {}
+	return 'Enter a SharePoint Online site URL without a query or fragment.';
+}
+
+// A field's `validate` returns a problem message for a non-empty value; `normalize` runs on every save.
+export const types = {
 	bitbucket: {
-		type: 'object',
 		title: 'Bitbucket',
-		properties: {
-			workspace: { type: 'string', title: 'Workspace' },
-			defaultRepo: { type: 'string', title: 'Default repo' },
-			email: { type: 'string', title: 'Email' },
-			token: { type: 'string', title: 'Token', writeOnly: true },
+		fields: {
+			workspace: { title: 'Workspace', message: 'Bitbucket workspace slug', placeholder: 'my-workspace', required: true },
+			defaultRepo: { title: 'Default repo', message: 'Bitbucket default repo slug', placeholder: 'my-repo' },
+			email: { title: 'Email', message: 'Bitbucket account email', placeholder: 'you@company.com', required: true },
+			token: { title: 'Token', message: 'Bitbucket API token', secret: true, required: true },
 		},
 	},
 	jira: {
-		type: 'object',
 		title: 'Jira',
-		properties: {
-			baseUrl: { type: 'string', title: 'Base URL' },
-			token: { type: 'string', title: 'Token', writeOnly: true },
-			defaultProject: { type: 'string', title: 'Default project' },
+		fields: {
+			baseUrl: { title: 'Base URL', message: 'Jira Server base URL', placeholder: 'https://jira.company.com', required: true },
+			token: { title: 'Token', message: 'Jira Personal Access Token', secret: true, required: true },
+			defaultProject: { title: 'Default project', message: 'Jira default project key', placeholder: 'PROJ' },
 		},
 	},
 	confluence: {
-		type: 'object',
 		title: 'Confluence',
-		properties: {
-			baseUrl: { type: 'string', title: 'Base URL' },
-			email: { type: 'string', title: 'Email' },
-			token: { type: 'string', title: 'Token', writeOnly: true },
-			defaultSpace: { type: 'string', title: 'Default space' },
+		fields: {
+			baseUrl: { title: 'Base URL', message: 'Confluence base URL (Cloud or Server/Data Center)', placeholder: 'https://company.atlassian.net', required: true },
+			email: { title: 'Email', message: 'Confluence account email (Server/Data Center: username, or empty for a personal access token)', placeholder: 'you@company.com' },
+			token: { title: 'Token', message: 'Confluence API token (Server/Data Center: personal access token or password)', secret: true, required: true },
+			defaultSpace: { title: 'Default space', message: 'Confluence default space key', placeholder: 'DEV' },
 		},
 	},
 	serviceDesk: {
-		type: 'object',
 		title: 'Service Desk',
-		properties: {
-			baseUrl: { type: 'string', title: 'Base URL' },
-			email: { type: 'string', title: 'Email' },
-			token: { type: 'string', title: 'Token', writeOnly: true },
-			defaultProject: { type: 'string', title: 'Default project' },
+		fields: {
+			baseUrl: { title: 'Base URL', message: 'Jira Service Desk Cloud base URL (use canonical *.atlassian.net, not a vanity domain)', placeholder: 'https://company.atlassian.net', required: true },
+			email: { title: 'Email', message: 'Service Desk account email', placeholder: 'you@company.com', required: true },
+			token: { title: 'Token', message: 'Service Desk API token', secret: true, required: true },
+			defaultProject: { title: 'Default project', message: 'Service Desk default project key', placeholder: 'TUKI' },
+		},
+	},
+	graph: {
+		title: 'Microsoft Graph',
+		note: 'Teams, email, calendars, and SharePoint share this application. No client secret is needed.\nRegister http://localhost under Mobile and desktop applications.\nDelegated permissions: User.Read, Chat.Read, Mail.Read, Sites.Read.All.\nOptional: Calendars.Read.Shared and Calendars.ReadBasic for calendars/free-busy; Mail.Read.Shared for shared email.\nAfter saving, run dev graph login (--all for one sign-in with every supported permission).',
+		fields: {
+			tenantId: { title: 'Tenant ID', message: 'Directory (tenant) ID', required: true, validate: validateGraphId, normalize: (v) => v.trim().toLowerCase() },
+			clientId: { title: 'Client ID', message: 'Application (client) ID', required: true, validate: validateGraphId, normalize: (v) => v.trim().toLowerCase() },
+			defaultSite: { title: 'Default site', message: 'Default SharePoint site URL (optional)', placeholder: 'https://company.sharepoint.com/sites/MySite', validate: validateGraphSite, normalize: (v) => v.trim().replace(/\/+$/, '') },
 		},
 	},
 };
 
+export function fieldProblem(type, key, value) {
+	const field = types[type].fields[key];
+	return value && field.validate ? field.validate(value) : undefined;
+}
+
 const config = new Conf({
 	projectName: 'devtool',
-	schema,
-	defaults: {
-		bitbucket: { workspace: '', defaultRepo: '', email: '', token: '' },
-		jira: { baseUrl: '', token: '', defaultProject: '' },
-		confluence: { baseUrl: '', email: '', token: '', defaultSpace: '' },
-		serviceDesk: { baseUrl: '', email: '', token: '', defaultProject: '' },
+	schema: {
+		connections: {
+			type: 'array',
+			items: {
+				type: 'object',
+				properties: {
+					type: { type: 'string', enum: Object.keys(types) },
+					name: { type: 'string' },
+					default: { type: 'boolean' },
+				},
+				required: ['type'],
+				additionalProperties: { type: 'string' },
+			},
+		},
 	},
+	defaults: { connections: [] },
 });
 
-export function get(key) {
-	return config.get(key);
+migrateLegacySections();
+
+// Older versions stored exactly one connection per type as a top-level section.
+function migrateLegacySections() {
+	const { connections = [], ...rest } = config.store;
+	const legacy = Object.keys(rest).filter((key) => types[key]);
+	if (!legacy.length) return;
+	for (const type of legacy) {
+		const connection = clean({ type, ...rest[type] });
+		const hasValues = Object.keys(connection).length > 1;
+		if (hasValues && !connections.some((c) => c.type === type && !c.name)) connections.push(connection);
+		delete rest[type];
+	}
+	config.store = { ...rest, connections };
+}
+
+function clean(connection) {
+	const result = { type: connection.type };
+	if (connection.name) result.name = connection.name;
+	if (connection.default) result.default = true;
+	for (const [key, field] of Object.entries(types[connection.type].fields)) {
+		if (typeof connection[key] !== 'string') continue;
+		const value = field.normalize ? field.normalize(connection[key]) : connection[key];
+		if (value !== '') result[key] = value;
+	}
+	return result;
 }
 
-export function set(key, value) {
-	config.set(key, value);
+function write(connections) {
+	config.set('connections', connections.map(clean));
 }
 
-export function getAll() {
-	return config.store;
+// An unnamed connection is addressed by its type, so labels stay unique across all connections.
+export function label(connection) {
+	return connection.name || connection.type;
 }
 
-export function isConfigured() {
-	const bb = config.get('bitbucket');
-	const jira = config.get('jira');
-	return !!(bb.workspace && bb.token && jira.baseUrl && jira.token);
+export function listConnections() {
+	return config.get('connections');
 }
 
-export function configPath() {
-	return config.path;
+function defaultIndex(connections, type) {
+	const flagged = connections.findIndex((c) => c.type === type && c.default);
+	return flagged !== -1 ? flagged : connections.findIndex((c) => c.type === type);
 }
 
-export async function runSetup() {
-	p.intro(pc.cyan('DevTool Setup'));
-
-	const bb = await p.group({
-		workspace: () => p.text({
-			message: 'Bitbucket workspace slug',
-			placeholder: 'my-workspace',
-			initialValue: config.get('bitbucket.workspace') || '',
-			validate: (v) => !v ? 'Required' : undefined,
-		}),
-		defaultRepo: () => p.text({
-			message: 'Bitbucket default repo slug',
-			placeholder: 'my-repo',
-			initialValue: config.get('bitbucket.defaultRepo') || '',
-			validate: (v) => !v ? 'Required' : undefined,
-		}),
-		email: () => p.text({
-			message: 'Bitbucket account email',
-			placeholder: 'you@company.com',
-			initialValue: config.get('bitbucket.email') || '',
-			validate: (v) => !v ? 'Required' : undefined,
-		}),
-		token: () => p.password({
-			message: 'Bitbucket API token',
-			validate: (v) => !v ? 'Required' : undefined,
-		}),
-	}, {
-		onCancel: () => {
-			p.cancel('Setup cancelled.');
-			process.exit(0);
-		},
-	});
-
-	const jira = await p.group({
-		baseUrl: () => p.text({
-			message: 'Jira Server base URL',
-			placeholder: 'https://jira.company.com',
-			initialValue: config.get('jira.baseUrl') || '',
-			validate: (v) => !v ? 'Required' : undefined,
-		}),
-		token: () => p.password({
-			message: 'Jira Personal Access Token',
-			validate: (v) => !v ? 'Required' : undefined,
-		}),
-		defaultProject: () => p.text({
-			message: 'Jira default project key',
-			placeholder: 'PROJ',
-			initialValue: config.get('jira.defaultProject') || '',
-			validate: (v) => !v ? 'Required' : undefined,
-		}),
-	}, {
-		onCancel: () => {
-			p.cancel('Setup cancelled.');
-			process.exit(0);
-		},
-	});
-
-	const confluence = await p.group({
-		baseUrl: () => p.text({
-			message: 'Confluence Cloud base URL',
-			placeholder: 'https://company.atlassian.net',
-			initialValue: config.get('confluence.baseUrl') || '',
-		}),
-		email: () => p.text({
-			message: 'Confluence account email',
-			placeholder: 'you@company.com',
-			initialValue: config.get('confluence.email') || '',
-		}),
-		token: () => p.password({
-			message: 'Confluence API token',
-		}),
-		defaultSpace: () => p.text({
-			message: 'Confluence default space key',
-			placeholder: 'DEV',
-			initialValue: config.get('confluence.defaultSpace') || '',
-		}),
-	}, {
-		onCancel: () => {
-			p.cancel('Setup cancelled.');
-			process.exit(0);
-		},
-	});
-
-	const reuseConfluenceCreds = confluence.email && confluence.token
-		? await p.confirm({
-			message: 'Reuse Confluence email/token for Jira Service Desk Cloud?',
-			initialValue: true,
-		})
-		: false;
-
-	if (p.isCancel(reuseConfluenceCreds)) {
-		p.cancel('Setup cancelled.');
-		process.exit(0);
+export function isDefault(connections, index) {
+	return defaultIndex(connections, connections[index].type) === index;
+}
+
+// A reference is a connection label; a bare type falls back to that type's default connection.
+function findIndex(connections, ref) {
+	const byLabel = connections.findIndex((c) => label(c) === ref);
+	if (byLabel !== -1 || !types[ref]) return byLabel;
+	return defaultIndex(connections, ref);
+}
+
+function requireIndex(connections, ref) {
+	const index = findIndex(connections, ref);
+	if (index === -1) throw new Error(`No connection named "${ref}". Run \`dev config show\` to list connections.`);
+	return index;
+}
+
+export function getConnection(type, ref) {
+	const connections = listConnections();
+	const { title } = types[type];
+	if (ref) {
+		const connection = connections[requireIndex(connections, ref)];
+		if (connection.type !== type) {
+			throw new Error(`Connection "${ref}" is a ${types[connection.type].title} connection, not ${title}.`);
+		}
+		return connection;
 	}
+	const index = defaultIndex(connections, type);
+	if (index === -1) throw new Error(`No ${title} connection configured. Run \`dev config add ${type}\` to add one.`);
+	return connections[index];
+}
 
-	const serviceDesk = await p.group({
-		baseUrl: () => p.text({
-			message: 'Jira Service Desk Cloud base URL (use canonical *.atlassian.net, not a vanity domain)',
-			placeholder: 'https://company.atlassian.net',
-			initialValue: config.get('serviceDesk.baseUrl') || '',
-		}),
-		email: () => reuseConfluenceCreds
-			? Promise.resolve(confluence.email)
-			: p.text({
-				message: 'Service Desk account email',
-				placeholder: 'you@company.com',
-				initialValue: config.get('serviceDesk.email') || '',
-			}),
-		token: () => reuseConfluenceCreds
-			? Promise.resolve(confluence.token)
-			: p.password({
-				message: 'Service Desk API token',
-			}),
-		defaultProject: () => p.text({
-			message: 'Service Desk default project key',
-			placeholder: 'TUKI',
-			initialValue: config.get('serviceDesk.defaultProject') || '',
-		}),
-	}, {
-		onCancel: () => {
-			p.cancel('Setup cancelled.');
-			process.exit(0);
-		},
-	});
+export function resolveIndex(ref) {
+	return requireIndex(listConnections(), ref);
+}
 
-	config.set('bitbucket', bb);
-	config.set('jira', jira);
-	config.set('confluence', confluence);
-	config.set('serviceDesk', serviceDesk);
+export function validateName(connections, connection, index = -1) {
+	const { name, type } = connection;
+	if (name) {
+		if (!/^[A-Za-z0-9][\w-]*$/.test(name)) {
+			return 'Use only letters, digits, "-" and "_", starting with a letter or digit';
+		}
+		if (Object.keys(types).some((t) => t.toLowerCase() === name.toLowerCase())) {
+			return `"${name}" is a connection type and cannot be a name`;
+		}
+	}
+	const clash = connections.some((c, i) => i !== index && label(c) === label(connection));
+	if (clash) {
+		return name
+			? `A connection named "${name}" already exists`
+			: `A ${types[type].title} connection without a name already exists; give this one a name`;
+	}
+	return undefined;
+}
 
-	p.outro(pc.green('Configuration saved!'));
+// Without an index the connection is appended.
+export function saveConnection(connection, index = -1) {
+	const connections = listConnections();
+	const problem = validateName(connections, connection, index);
+	if (problem) throw new Error(problem);
+	if (index === -1) connections.push(connection);
+	else connections[index] = connection;
+	write(connections);
+}
+
+export function removeConnection(ref) {
+	const connections = listConnections();
+	const [removed] = connections.splice(requireIndex(connections, ref), 1);
+	write(connections);
+	return removed;
+}
+
+export function setDefault(ref) {
+	const connections = listConnections();
+	const target = connections[requireIndex(connections, ref)];
+	for (const c of connections) {
+		if (c.type === target.type) c.default = c === target;
+	}
+	write(connections);
+	return target;
+}
+
+// A bare type with no connection yet creates one, so `config set jira.baseUrl ...` works on a fresh install.
+export function setField(ref, field, value) {
+	const connections = listConnections();
+	let index = findIndex(connections, ref);
+	if (index === -1) {
+		if (!types[ref]) throw new Error(`No connection named "${ref}". Run \`dev config show\` to list connections.`);
+		connections.push({ type: ref });
+		index = connections.length - 1;
+	}
+	const connection = connections[index];
+	const fields = Object.keys(types[connection.type].fields);
+	if (field !== 'name' && !fields.includes(field)) {
+		throw new Error(`Invalid field "${field}" for a ${types[connection.type].title} connection. Valid fields: name, ${fields.join(', ')}`);
+	}
+	connection[field] = value;
+	const problem = field === 'name'
+		? validateName(connections, connection, index)
+		: fieldProblem(connection.type, field, value);
+	if (problem) throw new Error(problem);
+	write(connections);
+	return connection;
+}
+
+export function configPath() {
+	return config.path;
 }
 
 export default config;