Creating a new database project, project items

* can create, open, and close sqlproj files
* can add sql objects to projects

extensions/sql-database-projects/src/controllers/databaseProjectTreeViewProvider.ts

@@ -6,7 +6,7 @@
 import * as vscode from 'vscode';
 import * as constants from '../common/constants';
 
-import { BaseProjectTreeItem, MessageTreeItem } from '../models/tree/baseTreeItem';
+import { BaseProjectTreeItem, MessageTreeItem, SpacerTreeItem } from '../models/tree/baseTreeItem';
 import { ProjectRootTreeItem } from '../models/tree/projectTreeItem';
 import { Project } from '../models/project';
 
@@ -39,16 +39,20 @@ export class SqlDatabaseProjectTreeViewProvider implements vscode.TreeDataProvid
 		return element.children;
 	}
 
+	/**
+	 * Constructs a new set of root nodes from a list of Projects
+	 * @param projects List of Projects
+	 */
 	public load(projects: Project[]) {
-		if (projects.length === 0) {
-			vscode.window.showErrorMessage(constants.noSqlProjFiles);
-			return;
-		}
-
 		let newRoots: BaseProjectTreeItem[] = [];
 
 		for (const proj of projects) {
 			newRoots.push(new ProjectRootTreeItem(proj));
+			newRoots.push(SpacerTreeItem);
+		}
+
+		if (newRoots[newRoots.length - 1] === SpacerTreeItem) {
+			newRoots.pop(); // get rid of the trailing SpacerTreeItem
 		}
 
 		this.roots = newRoots;

extensions/sql-database-projects/src/controllers/mainController.ts

@@ -4,16 +4,18 @@
  *--------------------------------------------------------------------------------------------*/
 
 import * as vscode from 'vscode';
-import * as nls from 'vscode-nls';
+import * as templateMap from '../templates/templateMap';
+import * as templates from '../templates/templates';
+import * as constants from '../common/constants';
+import * as path from 'path';
 
 import { SqlDatabaseProjectTreeViewProvider } from './databaseProjectTreeViewProvider';
 import { getErrorMessage } from '../common/utils';
 import { ProjectsController } from './projectController';
+import { BaseProjectTreeItem } from '../models/tree/baseTreeItem';
 
 const SQL_DATABASE_PROJECTS_VIEW_ID = 'sqlDatabaseProjectsView';
 
-const localize = nls.loadMessageBundle();
-
 /**
  * The main controller class that initializes the extension
  */
@@ -40,11 +42,21 @@ export default class MainController implements vscode.Disposable {
 
 	private async initializeDatabaseProjects(): Promise<void> {
 		// init commands
-		vscode.commands.registerCommand('sqlDatabaseProjects.new', () => { console.log('"New Database Project" called.'); });
-		vscode.commands.registerCommand('sqlDatabaseProjects.open', async () => { this.openProjectFromFile(); });
+		vscode.commands.registerCommand('sqlDatabaseProjects.new', async () => { await this.createNewProject(); });
+		vscode.commands.registerCommand('sqlDatabaseProjects.open', async () => { await this.openProjectFromFile(); });
+		vscode.commands.registerCommand('sqlDatabaseProjects.close', (node: BaseProjectTreeItem) => { this.projectsController.closeProject(node); });
+
+		vscode.commands.registerCommand('sqlDatabaseProjects.newScript', async (node: BaseProjectTreeItem) => { await this.projectsController.addItemPrompt(node, templateMap.script); });
+		vscode.commands.registerCommand('sqlDatabaseProjects.newTable', async (node: BaseProjectTreeItem) => { await this.projectsController.addItemPrompt(node, templateMap.table); });
+		vscode.commands.registerCommand('sqlDatabaseProjects.newView', async (node: BaseProjectTreeItem) => { await this.projectsController.addItemPrompt(node, templateMap.view); });
+		vscode.commands.registerCommand('sqlDatabaseProjects.newStoredProcedure', async (node: BaseProjectTreeItem) => { await this.projectsController.addItemPrompt(node, templateMap.storedProcedure); });
+		vscode.commands.registerCommand('sqlDatabaseProjects.newItem', async (node: BaseProjectTreeItem) => { await this.projectsController.addItemPrompt(node); });
+		vscode.commands.registerCommand('sqlDatabaseProjects.newFolder', async (node: BaseProjectTreeItem) => { await this.projectsController.addFolderPrompt(node); });
 
 		// init view
 		this.extensionContext.subscriptions.push(vscode.window.registerTreeDataProvider(SQL_DATABASE_PROJECTS_VIEW_ID, this.dbProjectTreeViewProvider));
+
+		await templates.loadTemplates(path.join(this._context.extensionPath, 'resources', 'templates'));
 	}
 
 	/**
@@ -55,7 +67,7 @@ export default class MainController implements vscode.Disposable {
 		try {
 			let filter: { [key: string]: string[] } = {};
 
-			filter[localize('sqlDatabaseProject', "SQL database project")] = ['sqlproj'];
+			filter[constants.sqlDatabaseProject] = ['sqlproj'];
 
 			let files: vscode.Uri[] | undefined = await vscode.window.showOpenDialog({ filters: filter });
 
@@ -70,6 +82,47 @@ export default class MainController implements vscode.Disposable {
 		}
 	}
 
+	/**
+	 * Creates a new SQL database project from a template, prompting the user for a name and location
+	 */
+	public async createNewProject(): Promise<void> {
+		try {
+			let newProjName = await vscode.window.showInputBox({
+				prompt: constants.newDatabaseProjectName,
+				value: `DatabaseProject${this.projectsController.projects.length + 1}`
+				// TODO: Smarter way to suggest a name.  Easy if we prompt for location first, but that feels odd...
+			});
+
+			if (!newProjName) {
+				// TODO: is this case considered an intentional cancellation (shouldn't warn) or an error case (should warn)?
+				vscode.window.showErrorMessage(constants.projectNameRequired);
+				return;
+			}
+
+			let selectionResult = await vscode.window.showOpenDialog({
+				canSelectFiles: false,
+				canSelectFolders: true,
+				canSelectMany: false,
+				defaultUri: vscode.workspace.workspaceFolders ? vscode.workspace.workspaceFolders[0].uri : undefined
+			});
+
+			if (!selectionResult) {
+				vscode.window.showErrorMessage(constants.projectLocationRequired);
+				return;
+			}
+
+			// TODO: what if the selected folder is outside the workspace?
+
+			const newProjFolderUri = (selectionResult as vscode.Uri[])[0];
+			console.log(newProjFolderUri.fsPath);
+			const newProjFilePath = await this.projectsController.createNewProject(newProjName as string, newProjFolderUri as vscode.Uri);
+			await this.projectsController.openProject(vscode.Uri.file(newProjFilePath));
+		}
+		catch (err) {
+			vscode.window.showErrorMessage(getErrorMessage(err));
+		}
+	}
+
 	public dispose(): void {
 		this.deactivate();
 	}

extensions/sql-database-projects/src/controllers/projectController.ts

@@ -4,11 +4,20 @@
  *--------------------------------------------------------------------------------------------*/
 
 import * as vscode from 'vscode';
-import { Project } from '../models/project';
-import { SqlDatabaseProjectTreeViewProvider } from './databaseProjectTreeViewProvider';
 import * as path from 'path';
 import * as constants from '../common/constants';
 import * as dataSources from '../models/dataSources/dataSources';
+import * as templateMap from '../templates/templateMap';
+import * as utils from '../common/utils';
+import * as UUID from 'vscode-languageclient/lib/utils/uuid';
+import * as templates from '../templates/templates';
+
+import { Project } from '../models/project';
+import { SqlDatabaseProjectTreeViewProvider } from './databaseProjectTreeViewProvider';
+import { promises as fs } from 'fs';
+import { BaseProjectTreeItem } from '../models/tree/baseTreeItem';
+import { ProjectRootTreeItem } from '../models/tree/projectTreeItem';
+import { FolderNode } from '../models/tree/fileFolderTreeItem';
 
 /**
  * Controller for managing project lifecycle
@@ -22,8 +31,18 @@ export class ProjectsController {
 		this.projectTreeViewProvider = projTreeViewProvider;
 	}
 
-	public async openProject(projectFile: vscode.Uri) {
-		console.log('Loading project: ' + projectFile.fsPath);
+
+	public refreshProjectsTree() {
+		this.projectTreeViewProvider.load(this.projects);
+	}
+
+	public async openProject(projectFile: vscode.Uri): Promise<Project> {
+		for (const proj of this.projects) {
+			if (proj.projectFilePath === projectFile.fsPath) {
+				vscode.window.showInformationMessage(constants.projectAlreadyOpened(projectFile.fsPath));
+				return proj;
+			}
+		}
 
 		// Read project file
 		const newProject = new Project(projectFile.fsPath);
@@ -32,12 +51,173 @@ export class ProjectsController {
 
 		// Read datasources.json (if present)
 		const dataSourcesFilePath = path.join(path.dirname(projectFile.fsPath), constants.dataSourcesFileName);
-		newProject.dataSources = await dataSources.load(dataSourcesFilePath);
+
+		try {
+			newProject.dataSources = await dataSources.load(dataSourcesFilePath);
+		}
+		catch (err) {
+			if (err instanceof dataSources.NoDataSourcesFileError) {
+				// TODO: prompt to create new datasources.json; for now, swallow
+				console.log(`No ${constants.dataSourcesFileName} file found.`);
+			}
+			else {
+				throw err;
+			}
+		}
+
+		this.refreshProjectsTree();
+
+		return newProject;
+	}
+
+	public async createNewProject(newProjName: string, folderUri: vscode.Uri, projectGuid?: string): Promise<string> {
+		if (projectGuid && !UUID.isUUID(projectGuid)) {
+			throw new Error(`Specified GUID is invalid: '${projectGuid}'`);
+		}
+
+		const macroDict: Record<string, string> = {
+			'PROJECT_NAME': newProjName,
+			'PROJECT_GUID': projectGuid ?? UUID.generateUuid().toUpperCase()
+		};
+
+		let newProjFileContents = this.macroExpansion(templates.newSqlProjectTemplate, macroDict);
+
+		let newProjFileName = newProjName;
+
+		if (!newProjFileName.toLowerCase().endsWith(constants.sqlprojExtension)) {
+			newProjFileName += constants.sqlprojExtension;
+		}
+
+		const newProjFilePath = path.join(folderUri.fsPath, newProjFileName);
+
+		let fileExists = false;
+		try {
+			await fs.access(newProjFilePath);
+			fileExists = true;
+		}
+		catch { } // file doesn't already exist
+
+		if (fileExists) {
+			throw new Error(constants.projectAlreadyExists(newProjFileName, folderUri.fsPath));
+		}
+
+		await fs.mkdir(path.dirname(newProjFilePath), { recursive: true });
+		await fs.writeFile(newProjFilePath, newProjFileContents);
+
+		return newProjFilePath;
+	}
+
+	public closeProject(treeNode: BaseProjectTreeItem) {
+		const project = this.getProjectContextFromTreeNode(treeNode);
+		this.projects = this.projects.filter((e) => { return e !== project; });
+		this.refreshProjectsTree();
+	}
+
+	public async addFolderPrompt(treeNode: BaseProjectTreeItem) {
+		const project = this.getProjectContextFromTreeNode(treeNode);
+		const newFolderName = await this.promptForNewObjectName(new templateMap.ProjectScriptType(templateMap.folder, 'Folder', ''), project);
+
+		if (!newFolderName) {
+			return; // user cancelled
+		}
+
+		const relativeFolderPath = this.prependContextPath(treeNode, newFolderName);
+
+		await project.addFolderItem(relativeFolderPath);
 
 		this.refreshProjectsTree();
 	}
 
-	public refreshProjectsTree() {
-		this.projectTreeViewProvider.load(this.projects);
+	public async addItemPrompt(treeNode: BaseProjectTreeItem, itemTypeName?: string) {
+		const project = this.getProjectContextFromTreeNode(treeNode);
+
+		if (!itemTypeName) {
+			let itemFriendlyNames: string[] = [];
+
+			for (const itemType of templateMap.projectScriptTypes) {
+				itemFriendlyNames.push(itemType.friendlyName);
+			}
+
+			itemTypeName = await vscode.window.showQuickPick(itemFriendlyNames, {
+				canPickMany: false
+			});
+
+			if (!itemTypeName) {
+				return; // user cancelled
+			}
+		}
+
+		const itemType = templateMap.projectScriptTypeMap[itemTypeName.toLocaleLowerCase()];
+		const itemObjectName = await this.promptForNewObjectName(itemType, project);
+
+		if (!itemObjectName) {
+			return; // user cancelled
+		}
+
+		// TODO: file already exists?
+
+		const newFileText = this.macroExpansion(itemType.templateScript, { 'OBJECT_NAME': itemObjectName });
+		const relativeFilePath = this.prependContextPath(treeNode, itemObjectName + '.sql');
+
+		const newEntry = await project.addScriptItem(relativeFilePath, newFileText);
+
+		vscode.commands.executeCommand('vscode.open', newEntry.fsUri);
+
+		this.refreshProjectsTree();
 	}
+
+	//#region Helper methods
+
+	private macroExpansion(template: string, macroDict: Record<string, string>): string {
+		const macroIndicator = '@@';
+		let output = template;
+
+		for (const macro in macroDict) {
+			// check if value contains the macroIndicator, which could break expansion for successive macros
+			if (macroDict[macro].includes(macroIndicator)) {
+				throw new Error(`Macro value ${macroDict[macro]} is invalid because it contains ${macroIndicator}`);
+			}
+
+			output = output.replace(new RegExp(macroIndicator + macro + macroIndicator, 'g'), macroDict[macro]);
+		}
+
+		return output;
+	}
+
+	private getProjectContextFromTreeNode(treeNode: BaseProjectTreeItem): Project {
+		if (!treeNode) {
+			// TODO: prompt for which (currently-open) project when invoked via command pallet
+			throw new Error('TODO: prompt for which project when invoked via command pallet');
+		}
+
+		if (treeNode.root instanceof ProjectRootTreeItem) {
+			return (treeNode.root as ProjectRootTreeItem).project;
+		}
+		else {
+			throw new Error('"Add item" command invoked from unexpected location: ' + treeNode.uri.path);
+		}
+	}
+
+	private async promptForNewObjectName(itemType: templateMap.ProjectScriptType, _project: Project): Promise<string | undefined> {
+		// TODO: ask project for suggested name that doesn't conflict
+		const suggestedName = itemType.friendlyName.replace(new RegExp('\s', 'g'), '') + '1';
+
+		const itemObjectName = await vscode.window.showInputBox({
+			prompt: constants.newObjectNamePrompt(itemType.friendlyName),
+			value: suggestedName,
+		});
+
+		return itemObjectName;
+	}
+
+	private prependContextPath(treeNode: BaseProjectTreeItem, objectName: string): string {
+		if (treeNode instanceof FolderNode) {
+			return path.join(utils.trimUri(treeNode.root.uri, treeNode.uri), objectName);
+		}
+		else {
+			return objectName;
+		}
+	}
+
+	//#endregion
 }