Add validation for new file names for sql projects (#21601)

* Add validation for new file names for sql projects

* Addres comments and add validation for new project dialog

* Address comments

* Address comments on test

* Fix tests

* Remove extra error messages and rename file

* Address comments

* Fix tests

* Add test file back

extensions/data-workspace/src/common/constants.ts

@@ -58,6 +58,14 @@ export const SdkLearnMorePlaceholder = localize('dataworkspace.sdkLearnMorePlace
 export const Default = localize('dataworkspace.default', "Default");
 export const SelectTargetPlatform = localize('dataworkspace.selectTargetPlatform', "Select Target Platform");
 export const LocalDevInfo = (target: string) => localize('LocalDevInfo', "Click \"Learn more\" button for more information about local development experience to {0}", target);
+export const undefinedFilenameErrorMessage = localize('undefinedFilenameErrorMessage', "Undefined name");
+export const filenameEndingIsPeriodErrorMessage = localize('filenameEndingInPeriodErrorMessage', "File name cannot end with a period");
+export const whitespaceFilenameErrorMessage = localize('whitespaceFilenameErrorMessage', "File name cannot be whitespace");
+export const invalidFileCharsErrorMessage = localize('invalidFileCharsErrorMessage', "Invalid file characters");
+export const reservedWindowsFilenameErrorMessage = localize('reservedWindowsFilenameErrorMessage', "This file name is reserved for use by Windows. Choose another name and try again");
+export const reservedValueErrorMessage = localize('reservedValueErrorMessage', "Reserved file name. Choose another name and try again");
+export const trailingWhitespaceErrorMessage = localize('trailingWhitespaceErrorMessage', "File name cannot end with a whitespace");
+export const tooLongFilenameErrorMessage = localize('tooLongFilenameErrorMessage', "File name cannot be over 255 characters");
 
 //Open Existing Dialog
 export const OpenExistingDialogTitle = localize('dataworkspace.openExistingDialogTitle', "Open Existing Project");

extensions/data-workspace/src/common/dataWorkspaceExtension.ts

@@ -8,6 +8,7 @@ import { IExtension, IProjectType } from 'dataworkspace';
 import { WorkspaceService } from '../services/workspaceService';
 import { defaultProjectSaveLocation } from './projectLocationHelper';
 import { openSpecificProjectNewProjectDialog } from '../dialogs/newProjectDialog';
+import { isValidBasename, isValidBasenameErrorMessage, isValidFilenameCharacter, sanitizeStringForFilename } from './pathUtilsHelper';
 
 export class DataWorkspaceExtension implements IExtension {
 	constructor(private workspaceService: WorkspaceService) {
@@ -41,4 +42,20 @@ export class DataWorkspaceExtension implements IExtension {
 		return openSpecificProjectNewProjectDialog(projectType, this.workspaceService);
 	}
 
+	isValidFilenameCharacter(c: string): boolean {
+		return isValidFilenameCharacter(c);
+	}
+
+	sanitizeStringForFilename(s: string): string {
+		return sanitizeStringForFilename(s);
+	}
+
+	isValidBasename(name?: string): boolean {
+		return isValidBasename(name);
+	}
+
+	isValidBasenameErrorMessage(name?: string): string {
+		return isValidBasenameErrorMessage(name);
+	}
+
 }

extensions/data-workspace/src/common/pathUtilsHelper.ts

@@ -0,0 +1,136 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as constants from './constants';
+import * as os from 'os';
+import * as path from 'path';
+
+const WINDOWS_INVALID_FILE_CHARS = /[\\/:\*\?"<>\|]/g;
+const UNIX_INVALID_FILE_CHARS = /[\\/]/g;
+const isWindows = os.platform() === 'win32';
+const WINDOWS_FORBIDDEN_NAMES = /^(con|prn|aux|clock\$|nul|lpt[0-9]|com[0-9])$/i;
+
+/**
+ * Determines if a given character is a valid filename character
+ * @param c Character to validate
+ */
+export function isValidFilenameCharacter(c: string): boolean {
+	// only a character should be passed
+	if (!c || c.length !== 1) {
+		return false;
+	}
+	WINDOWS_INVALID_FILE_CHARS.lastIndex = 0;
+	UNIX_INVALID_FILE_CHARS.lastIndex = 0;
+	if (isWindows && WINDOWS_INVALID_FILE_CHARS.test(c)) {
+		return false;
+	} else if (!isWindows && UNIX_INVALID_FILE_CHARS.test(c)) {
+		return false;
+	}
+
+	return true;
+}
+
+/**
+ * Replaces invalid filename characters in a string with underscores
+ * @param s The string to be sanitized for a filename
+ */
+export function sanitizeStringForFilename(s: string): string {
+	// replace invalid characters with an underscore
+	let result = '';
+	for (let i = 0; i < s.length; ++i) {
+		result += isValidFilenameCharacter(s[i]) ? s[i] : '_';
+	}
+
+	return result;
+}
+
+/**
+ * Returns true if the string is a valid filename
+ * Logic is copied from src\vs\base\common\extpath.ts
+ * @param name filename to check
+ */
+export function isValidBasename(name?: string): boolean {
+	const invalidFileChars = isWindows ? WINDOWS_INVALID_FILE_CHARS : UNIX_INVALID_FILE_CHARS;
+
+	if (!name) {
+		return false;
+	}
+
+	if (isWindows && name[name.length - 1] === '.') {
+		return false; // Windows: file cannot end with a "."
+	}
+
+	let basename = path.parse(name).name;
+	if (!basename || basename.length === 0 || /^\s+$/.test(basename)) {
+		return false; // require a name that is not just whitespace
+	}
+
+	invalidFileChars.lastIndex = 0;
+	if (invalidFileChars.test(basename)) {
+		return false; // check for certain invalid file characters
+	}
+
+	if (isWindows && WINDOWS_FORBIDDEN_NAMES.test(basename)) {
+		return false; // check for certain invalid file names
+	}
+
+	if (basename === '.' || basename === '..') {
+		return false; // check for reserved values
+	}
+
+	if (isWindows && basename.length !== basename.trim().length) {
+		return false; // Windows: file cannot end with a whitespace
+	}
+
+	if (basename.length > 255) {
+		return false; // most file systems do not allow files > 255 length
+	}
+
+	return true;
+}
+
+/**
+ * Returns specific error message if file name is invalid
+ * Logic is copied from src\vs\base\common\extpath.ts
+ * @param name filename to check
+ */
+export function isValidBasenameErrorMessage(name?: string): string {
+	const invalidFileChars = isWindows ? WINDOWS_INVALID_FILE_CHARS : UNIX_INVALID_FILE_CHARS;
+	if (!name) {
+		return constants.undefinedFilenameErrorMessage;
+	}
+
+	if (isWindows && name[name.length - 1] === '.') {
+		return constants.filenameEndingIsPeriodErrorMessage; // Windows: file cannot end with a "."
+	}
+
+	let basename = path.parse(name).name;
+	if (!basename || basename.length === 0 || /^\s+$/.test(basename)) {
+		return constants.whitespaceFilenameErrorMessage; // require a name that is not just whitespace
+	}
+
+	invalidFileChars.lastIndex = 0;
+	if (invalidFileChars.test(basename)) {
+		return constants.invalidFileCharsErrorMessage; // check for certain invalid file characters
+	}
+
+	if (isWindows && WINDOWS_FORBIDDEN_NAMES.test(basename)) {
+		return constants.reservedWindowsFilenameErrorMessage; // check for certain invalid file names
+	}
+
+	if (basename === '.' || basename === '..') {
+		return constants.reservedValueErrorMessage; // check for reserved values
+	}
+
+	if (isWindows && basename.length !== basename.trim().length) {
+		return constants.trailingWhitespaceErrorMessage; // Windows: file cannot end with a whitespace
+	}
+
+	if (basename.length > 255) {
+		return constants.tooLongFilenameErrorMessage; // most file systems do not allow files > 255 length
+	}
+
+	return '';
+}

extensions/data-workspace/src/dataworkspace.d.ts

@@ -54,6 +54,32 @@ declare module 'dataworkspace' {
 		 * @returns the uri of the created the project or undefined if no project was created
 		 */
 		openSpecificProjectNewProjectDialog(projectType: IProjectType): Promise<vscode.Uri | undefined>;
+
+		/**
+		 * Determines if a given character is a valid filename character
+		 * @param c Character to validate
+		 */
+		isValidFilenameCharacter(c: string): boolean;
+
+		/**
+		 * Replaces invalid filename characters in a string with underscores
+		 * @param s The string to be sanitized for a filename
+		*/
+		sanitizeStringForFilename(s: string): string;
+
+		/**
+		 * Returns true if the string is a valid filename
+		 * Logic is copied from src\vs\base\common\extpath.ts
+		 * @param name filename to check
+		*/
+		isValidBasename(name: string | null | undefined): boolean;
+
+		/**
+		 * Returns specific error message if file name is invalid
+		 * Logic is copied from src\vs\base\common\extpath.ts
+		 * @param name filename to check
+		 */
+		isValidBasenameErrorMessage(name: string | null | undefined): string;
 	}
 
 	/**
@@ -94,7 +120,7 @@ declare module 'dataworkspace' {
 		/**
 		 * Gets the project image to be used as background in dashboard container
 		 */
-		 readonly image?: azdata.ThemedIconPath;
+		readonly image?: azdata.ThemedIconPath;
 	}
 
 	/**
@@ -233,4 +259,5 @@ declare module 'dataworkspace' {
 	 * Union type representing data types in dashboard table
 	 */
 	export type IDashboardColumnType = 'string' | 'icon';
+
 }

extensions/data-workspace/src/dialogs/newProjectDialog.ts

@@ -15,6 +15,7 @@ import { IconPathHelper } from '../common/iconHelper';
 import { defaultProjectSaveLocation } from '../common/projectLocationHelper';
 import { TelemetryActions, TelemetryReporter, TelemetryViews } from '../common/telemetry';
 import { WorkspaceService } from '../services/workspaceService';
+import { isValidBasename, isValidBasenameErrorMessage } from '../common/pathUtilsHelper';
 
 class NewProjectDialogModel {
 	projectTypeId: string = '';
@@ -174,16 +175,25 @@ export class NewProjectDialog extends DialogBase {
 			}
 		}));
 
-		const projectNameTextBox = view.modelBuilder.inputBox().withProps({
-			ariaLabel: constants.ProjectNameTitle,
-			placeHolder: constants.ProjectNamePlaceholder,
-			required: true,
-			width: constants.DefaultInputWidth
-		}).component();
+		const projectNameTextBox = view.modelBuilder.inputBox().withValidation(
+			component => isValidBasename(component.value)
+		)
+			.withProps({
+				ariaLabel: constants.ProjectNameTitle,
+				placeHolder: constants.ProjectNamePlaceholder,
+				required: true,
+				width: constants.DefaultInputWidth
+			}).component();
 
-		this.register(projectNameTextBox.onTextChanged(() => {
-			this.model.name = projectNameTextBox.value!;
-			return projectNameTextBox.updateProperty('title', projectNameTextBox.value);
+		this.register(projectNameTextBox.onTextChanged(text => {
+			const errorMessage = isValidBasenameErrorMessage(text);
+			if (errorMessage) {
+				// Set validation error message if project name is invalid
+				return void projectNameTextBox.updateProperty('validationErrorMessage', errorMessage);
+			} else {
+				this.model.name = projectNameTextBox.value!;
+				return projectNameTextBox.updateProperty('title', projectNameTextBox.value);
+			}
 		}));
 
 		const locationTextBox = view.modelBuilder.inputBox().withProps({

extensions/data-workspace/src/dialogs/newProjectQuickpick.ts

@@ -9,6 +9,7 @@ import * as constants from '../common/constants';
 import { directoryExist, showInfoMessageWithLearnMoreLink } from '../common/utils';
 import { defaultProjectSaveLocation } from '../common/projectLocationHelper';
 import { WorkspaceService } from '../services/workspaceService';
+import { isValidBasename, isValidBasenameErrorMessage } from '../common/pathUtilsHelper';
 
 /**
  * Create flow for a New Project using only VS Code-native APIs such as QuickPick
@@ -39,7 +40,7 @@ export async function createNewProjectWithQuickpick(workspaceService: WorkspaceS
 		{
 			title: constants.EnterProjectName,
 			validateInput: (value) => {
-				return value ? undefined : constants.NameCannotBeEmpty;
+				return isValidBasename(value) ? undefined : isValidBasenameErrorMessage(value);
 			},
 			ignoreFocusOut: true
 		});

extensions/data-workspace/src/test/dialogs/pathUtilsHelper.test.ts

@@ -0,0 +1,167 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as should from 'should';
+import * as constants from '../../common/constants';
+import * as os from 'os';
+import * as path from 'path';
+import { isValidBasename, isValidBasenameErrorMessage } from '../../common/pathUtilsHelper';
+
+const isWindows = os.platform() === 'win32';
+
+suite('Check for invalid filename tests', function (): void {
+	test('Should determine invalid filenames', async () => {
+		// valid filename
+		should(isValidBasename(formatFileName('ValidName.sqlproj'))).equal(true);
+
+		// invalid for both Windows and non-Windows
+		let invalidNames: string[] = [
+			'	.sqlproj',
+			' .sqlproj',
+			'  	.sqlproj',
+			'..sqlproj',
+			'...sqlproj',
+			// most file systems do not allow files > 255 length
+			'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.sqlproj'
+		];
+
+		for (let invalidName of invalidNames) {
+			should(isValidBasename(formatFileName(invalidName))).equal(false);
+		}
+
+		should(isValidBasename(undefined)).equal(false);
+		should(isValidBasename('\\')).equal(false);
+		should(isValidBasename('/')).equal(false);
+	});
+
+	test('Should determine invalid Windows filenames', async () => {
+		let invalidNames: string[] = [
+			// invalid characters only for Windows
+			'?.sqlproj',
+			':.sqlproj',
+			'*.sqlproj',
+			'<.sqlproj',
+			'>.sqlproj',
+			'|.sqlproj',
+			'".sqlproj',
+			// Windows filenames cannot end with a whitespace
+			'test   .sqlproj',
+			'test	.sqlproj'
+		];
+
+		for (let invalidName of invalidNames) {
+			should(isValidBasename(formatFileName(invalidName))).equal(isWindows ? false : true);
+		}
+	});
+
+	test('Should determine Windows forbidden filenames', async () => {
+		let invalidNames: string[] = [
+			// invalid only for Windows
+			'CON.sqlproj',
+			'PRN.sqlproj',
+			'AUX.sqlproj',
+			'NUL.sqlproj',
+			'COM1.sqlproj',
+			'COM2.sqlproj',
+			'COM3.sqlproj',
+			'COM4.sqlproj',
+			'COM5.sqlproj',
+			'COM6.sqlproj',
+			'COM7.sqlproj',
+			'COM8.sqlproj',
+			'COM9.sqlproj',
+			'LPT1.sqlproj',
+			'LPT2.sqlproj',
+			'LPT3.sqlproj',
+			'LPT4.sqlproj',
+			'LPT5.sqlproj',
+			'LPT6.sqlproj',
+			'LPT7.sqlproj',
+			'LPT8.sqlproj',
+			'LPT9.sqlproj',
+		];
+
+		for (let invalidName of invalidNames) {
+			should(isValidBasename(formatFileName(invalidName))).equal(isWindows ? false : true);
+		}
+	});
+});
+
+suite('Check for invalid filename error tests', function (): void {
+	test('Should determine invalid filenames', async () => {
+		// valid filename
+		should(isValidBasenameErrorMessage(formatFileName('ValidName.sqlproj'))).equal('');
+
+		// invalid for both Windows and non-Windows
+		should(isValidBasenameErrorMessage(formatFileName('	.sqlproj'))).equal(constants.whitespaceFilenameErrorMessage);
+		should(isValidBasenameErrorMessage(formatFileName(' .sqlproj'))).equal(constants.whitespaceFilenameErrorMessage);
+		should(isValidBasenameErrorMessage(formatFileName('  	.sqlproj'))).equal(constants.whitespaceFilenameErrorMessage);
+		should(isValidBasenameErrorMessage(formatFileName('..sqlproj'))).equal(constants.reservedValueErrorMessage);
+		should(isValidBasenameErrorMessage(formatFileName('...sqlproj'))).equal(constants.reservedValueErrorMessage);
+		should(isValidBasenameErrorMessage(undefined)).equal(constants.undefinedFilenameErrorMessage);
+		should(isValidBasenameErrorMessage('\\')).equal(isWindows ? constants.whitespaceFilenameErrorMessage : constants.invalidFileCharsErrorMessage);
+		should(isValidBasenameErrorMessage('/')).equal(constants.whitespaceFilenameErrorMessage);
+
+		// most file systems do not allow files > 255 length
+		should(isValidBasenameErrorMessage(formatFileName('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.sqlproj'))).equal(constants.tooLongFilenameErrorMessage);
+	});
+
+	test('Should determine invalid Windows filenames', async () => {
+		let invalidNames: string[] = [
+			// invalid characters only for Windows
+			'?.sqlproj',
+			':.sqlproj',
+			'*.sqlproj',
+			'<.sqlproj',
+			'>.sqlproj',
+			'|.sqlproj',
+			'".sqlproj'
+		];
+
+		for (let invalidName of invalidNames) {
+			should(isValidBasenameErrorMessage(formatFileName(invalidName))).equal(isWindows ? constants.invalidFileCharsErrorMessage : '');
+		}
+		// Windows filenames cannot end with a whitespace
+		should(isValidBasenameErrorMessage(formatFileName('test   .sqlproj'))).equal(isWindows ? constants.trailingWhitespaceErrorMessage : '');
+		should(isValidBasenameErrorMessage(formatFileName('test	.sqlproj'))).equal(isWindows ? constants.trailingWhitespaceErrorMessage : '');
+	});
+
+	test('Should determine Windows forbidden filenames', async () => {
+		let invalidNames: string[] = [
+			// invalid only for Windows
+			'CON.sqlproj',
+			'PRN.sqlproj',
+			'AUX.sqlproj',
+			'NUL.sqlproj',
+			'COM1.sqlproj',
+			'COM2.sqlproj',
+			'COM3.sqlproj',
+			'COM4.sqlproj',
+			'COM5.sqlproj',
+			'COM6.sqlproj',
+			'COM7.sqlproj',
+			'COM8.sqlproj',
+			'COM9.sqlproj',
+			'LPT1.sqlproj',
+			'LPT2.sqlproj',
+			'LPT3.sqlproj',
+			'LPT4.sqlproj',
+			'LPT5.sqlproj',
+			'LPT6.sqlproj',
+			'LPT7.sqlproj',
+			'LPT8.sqlproj',
+			'LPT9.sqlproj',
+		];
+
+		for (let invalidName of invalidNames) {
+			should(isValidBasenameErrorMessage(formatFileName(invalidName))).equal(isWindows ? constants.reservedWindowsFilenameErrorMessage : '');
+		}
+	});
+});
+
+function formatFileName(filename: string): string {
+	return path.join(os.tmpdir(), filename);
+}
+