Add creating extension packs when opening the editor

Author: koesie10

extensions/ql-vscode/src/data-extensions-editor/extension-pack-picker.ts

@@ -1,23 +1,38 @@
-import { relative, resolve, sep } from "path";
-import { pathExists, readFile } from "fs-extra";
-import { load as loadYaml } from "js-yaml";
+import { join, relative, resolve, sep } from "path";
+import { outputFile, pathExists, readFile } from "fs-extra";
+import { dump as dumpYaml, load as loadYaml } from "js-yaml";
 import { minimatch } from "minimatch";
 import { CancellationToken, window } from "vscode";
 import { CodeQLCliServer } from "../cli";
-import { getOnDiskWorkspaceFolders, showAndLogErrorMessage } from "../helpers";
+import {
+  getOnDiskWorkspaceFolders,
+  getOnDiskWorkspaceFoldersObjects,
+  showAndLogErrorMessage,
+} from "../helpers";
 import { ProgressCallback } from "../progress";
 import { DatabaseItem } from "../local-databases";
 import { getQlPackPath, QLPACK_FILENAMES } from "../pure/ql";
 
 const maxStep = 3;
 
+const packNamePartRegex = /[a-z0-9](?:[a-z0-9-]*[a-z0-9])?/;
+const packNameRegex = new RegExp(
+  `^(?:(?<scope>${packNamePartRegex.source})/)?(?<name>${packNamePartRegex.source})$`,
+);
+const packNameLength = 128;
+
 export async function pickExtensionPackModelFile(
   cliServer: Pick<CodeQLCliServer, "resolveQlpacks" | "resolveExtensions">,
   databaseItem: Pick<DatabaseItem, "name">,
   progress: ProgressCallback,
   token: CancellationToken,
 ): Promise<string | undefined> {
-  const extensionPackPath = await pickExtensionPack(cliServer, progress, token);
+  const extensionPackPath = await pickExtensionPack(
+    cliServer,
+    databaseItem,
+    progress,
+    token,
+  );
   if (!extensionPackPath) {
     return;
   }
@@ -38,6 +53,7 @@ export async function pickExtensionPackModelFile(
 
 async function pickExtensionPack(
   cliServer: Pick<CodeQLCliServer, "resolveQlpacks">,
+  databaseItem: Pick<DatabaseItem, "name">,
   progress: ProgressCallback,
   token: CancellationToken,
 ): Promise<string | undefined> {
@@ -50,10 +66,20 @@ async function pickExtensionPack(
   // Get all existing extension packs in the workspace
   const additionalPacks = getOnDiskWorkspaceFolders();
   const extensionPacks = await cliServer.resolveQlpacks(additionalPacks, true);
-  const options = Object.keys(extensionPacks).map((pack) => ({
-    label: pack,
-    extensionPack: pack,
-  }));
+
+  if (Object.keys(extensionPacks).length === 0) {
+    return pickNewExtensionPack(databaseItem, token);
+  }
+
+  const options: Array<{ label: string; extensionPack: string | null }> =
+    Object.keys(extensionPacks).map((pack) => ({
+      label: pack,
+      extensionPack: pack,
+    }));
+  options.push({
+    label: "Create new extension pack",
+    extensionPack: null,
+  });
 
   progress({
     message: "Choosing extension pack...",
@@ -72,6 +98,10 @@ async function pickExtensionPack(
     return undefined;
   }
 
+  if (!extensionPackOption.extensionPack) {
+    return pickNewExtensionPack(databaseItem, token);
+  }
+
   const extensionPackPaths = extensionPacks[extensionPackOption.extensionPack];
   if (extensionPackPaths.length !== 1) {
     void showAndLogErrorMessage(
@@ -153,6 +183,89 @@ async function pickModelFile(
   return pickNewModelFile(databaseItem, extensionPackPath, token);
 }
 
+async function pickNewExtensionPack(
+  databaseItem: Pick<DatabaseItem, "name">,
+  token: CancellationToken,
+): Promise<string | undefined> {
+  const workspaceFolders = getOnDiskWorkspaceFoldersObjects();
+  const workspaceFolderOptions = workspaceFolders.map((folder) => ({
+    label: folder.name,
+    detail: folder.uri.fsPath,
+    path: folder.uri.fsPath,
+  }));
+
+  // We're not using window.showWorkspaceFolderPick because that also includes the database source folders while
+  // we only want to include on-disk workspace folders.
+  const workspaceFolder = await window.showQuickPick(workspaceFolderOptions, {
+    title: "Select workspace folder to create extension pack in",
+  });
+  if (!workspaceFolder) {
+    return undefined;
+  }
+
+  const packName = await window.showInputBox(
+    {
+      title: "Create new extension pack",
+      prompt: "Enter name of extension pack",
+      placeHolder: `e.g. ${databaseItem.name}-extensions`,
+      validateInput: async (value: string): Promise<string | undefined> => {
+        if (!value) {
+          return "Pack name must not be empty";
+        }
+
+        if (value.length > packNameLength) {
+          return `Pack name must be no longer than ${packNameLength} characters`;
+        }
+
+        const matches = packNameRegex.exec(value);
+        if (!matches?.groups) {
+          return "Invalid package name: a pack name must contain only lowercase ASCII letters, ASCII digits, and hyphens";
+        }
+
+        const packPath = join(workspaceFolder.path, matches.groups.name);
+        if (await pathExists(packPath)) {
+          return `A pack already exists at ${packPath}`;
+        }
+
+        return undefined;
+      },
+    },
+    token,
+  );
+  if (!packName) {
+    return undefined;
+  }
+
+  const matches = packNameRegex.exec(packName);
+  if (!matches?.groups) {
+    return;
+  }
+
+  const name = matches.groups.name;
+  const packPath = join(workspaceFolder.path, name);
+
+  if (await pathExists(packPath)) {
+    return undefined;
+  }
+
+  const packYamlPath = join(packPath, "codeql-pack.yml");
+
+  await outputFile(
+    packYamlPath,
+    dumpYaml({
+      name,
+      version: "0.0.0",
+      library: true,
+      extensionTargets: {
+        "codeql/java-all": "*",
+      },
+      dataExtensions: ["models/**/*.yml"],
+    }),
+  );
+
+  return packPath;
+}
+
 async function pickNewModelFile(
   databaseItem: Pick<DatabaseItem, "name">,
   extensionPackPath: string,

extensions/ql-vscode/src/helpers.ts

@@ -16,6 +16,7 @@ import {
   window as Window,
   workspace,
   env,
+  WorkspaceFolder,
 } from "vscode";
 import { CodeQLCliServer, QlpacksInfo } from "./cli";
 import { UserCancellationException } from "./progress";
@@ -249,16 +250,21 @@ export async function showInformationMessageWithAction(
 }
 
 /** Gets all active workspace folders that are on the filesystem. */
-export function getOnDiskWorkspaceFolders() {
+export function getOnDiskWorkspaceFoldersObjects() {
   const workspaceFolders = workspace.workspaceFolders || [];
-  const diskWorkspaceFolders: string[] = [];
+  const diskWorkspaceFolders: WorkspaceFolder[] = [];
   for (const workspaceFolder of workspaceFolders) {
     if (workspaceFolder.uri.scheme === "file")
-      diskWorkspaceFolders.push(workspaceFolder.uri.fsPath);
+      diskWorkspaceFolders.push(workspaceFolder);
   }
   return diskWorkspaceFolders;
 }
 
+/** Gets all active workspace folders that are on the filesystem. */
+export function getOnDiskWorkspaceFolders() {
+  return getOnDiskWorkspaceFoldersObjects().map((folder) => folder.uri.fsPath);
+}
+
 /** Check if folder is already present in workspace */
 export function isFolderAlreadyInWorkspace(folderName: string) {
   const workspaceFolders = workspace.workspaceFolders || [];