repoburg 1.0.59 → 1.0.60

package/backend/node_modules/tsconfig-paths/src/__tests__/tsconfig-loader.test.ts

@@ -0,0 +1,428 @@
+import {
+  loadTsconfig,
+  tsConfigLoader,
+  walkForTsConfig,
+} from "../tsconfig-loader";
+import { join } from "path";
+
+describe("tsconfig-loader", () => {
+  it("should find tsconfig in cwd", () => {
+    const result = tsConfigLoader({
+      cwd: "/foo/bar",
+      getEnv: (_: string) => undefined,
+      loadSync: (cwd: string) => {
+        return {
+          tsConfigPath: `${cwd}/tsconfig.json`,
+          baseUrl: "./",
+          paths: {},
+        };
+      },
+    });
+
+    expect(result.tsConfigPath).toBe("/foo/bar/tsconfig.json");
+  });
+
+  it("should return loaderResult.tsConfigPath as undefined when not found", () => {
+    const result = tsConfigLoader({
+      cwd: "/foo/bar",
+      getEnv: (_: string) => undefined,
+      loadSync: (_: string) => {
+        return {
+          tsConfigPath: undefined,
+          baseUrl: "./",
+          paths: {},
+        };
+      },
+    });
+
+    expect(result.tsConfigPath).toBeUndefined();
+  });
+
+  it("should use TS_NODE_PROJECT env if exists", () => {
+    const result = tsConfigLoader({
+      cwd: "/foo/bar",
+      getEnv: (key: string) =>
+        key === "TS_NODE_PROJECT" ? "/foo/baz" : undefined,
+      loadSync: (cwd: string, fileName: string) => {
+        if (cwd === "/foo/bar" && fileName === "/foo/baz") {
+          return {
+            tsConfigPath: "/foo/baz/tsconfig.json",
+            baseUrl: "./",
+            paths: {},
+          };
+        }
+
+        return {
+          tsConfigPath: undefined,
+          baseUrl: "./",
+          paths: {},
+        };
+      },
+    });
+
+    expect(result.tsConfigPath).toBe("/foo/baz/tsconfig.json");
+  });
+
+  it("should use TS_NODE_BASEURL env if exists", () => {
+    const result = tsConfigLoader({
+      cwd: "/foo/bar",
+      getEnv: (key: string) =>
+        key === "TS_NODE_BASEURL" ? "SOME_BASEURL" : undefined,
+      loadSync: (_0: string, _1: string, baseUrl: string) => {
+        return {
+          tsConfigPath: undefined,
+          baseUrl,
+          paths: {},
+        };
+      },
+    });
+
+    expect(result.baseUrl).toBe("SOME_BASEURL");
+  });
+
+  it("should not use TS_NODE_BASEURL env if it does not exist", () => {
+    const result = tsConfigLoader({
+      cwd: "/foo/bar",
+      getEnv: (_: string) => {
+        return undefined;
+      },
+      loadSync: (_0: string, _1: string, baseUrl: string) => {
+        return {
+          tsConfigPath: undefined,
+          baseUrl,
+          paths: {},
+        };
+      },
+    });
+
+    expect(result.baseUrl).toBeUndefined();
+  });
+});
+
+describe("walkForTsConfig", () => {
+  it("should find tsconfig in starting directory", () => {
+    const pathToTsconfig = join("/root", "dir1", "tsconfig.json");
+    const mockFiles: Record<string, string[]> = {
+      "/root/dir1": ["tsconfig.json"],
+    };
+    const res = walkForTsConfig(
+      join("/root", "dir1"),
+      (path) => mockFiles[path] || []
+    );
+    expect(res).toBe(pathToTsconfig);
+  });
+
+  it("should find jsconfig in starting directory", () => {
+    const pathToJsconfig = join("/root", "dir1", "jsconfig.json");
+    const mockFiles: Record<string, string[]> = {
+      "/root/dir1": ["jsconfig.json"],
+    };
+    const res = walkForTsConfig(
+      join("/root", "dir1"),
+      (path) => mockFiles[path] || []
+    );
+    expect(res).toBe(pathToJsconfig);
+  });
+
+  // see https://github.com/Microsoft/TypeScript/issues/15869#issuecomment-301845650
+  it("tsconfig.json take precedence over jsconfig.json when both exist", () => {
+    const pathToTsconfig = join("/root/dir1", "tsconfig.json");
+    const mockFiles: Record<string, string[]> = {
+      "/root/dir1": ["jsconfig.json", "tsconfig.json"],
+    };
+    const res = walkForTsConfig(
+      join("/root", "dir1"),
+      (path) => mockFiles[path] || []
+    );
+    expect(res).toBe(pathToTsconfig);
+  });
+
+  it("should find tsconfig in parent directory", () => {
+    const pathToTsconfig = join("/root", "tsconfig.json");
+    const mockFiles: Record<string, string[]> = {
+      "/root": ["tsconfig.json"],
+    };
+    const res = walkForTsConfig(
+      join("/root", "dir1"),
+      (path) => mockFiles[path] || []
+    );
+    expect(res).toBe(pathToTsconfig);
+  });
+
+  it("should find jsconfig in parent directory", () => {
+    const pathToTsconfig = join("/root", "jsconfig.json");
+    const mockFiles: Record<string, string[]> = {
+      "/root": ["jsconfig.json"],
+    };
+    const res = walkForTsConfig(
+      join("/root", "dir1"),
+      (path) => mockFiles[path] || []
+    );
+    expect(res).toBe(pathToTsconfig);
+  });
+
+  it("should return undefined when reaching the top", () => {
+    const res = walkForTsConfig(join("/root", "dir1", "kalle"), () => []);
+    expect(res).toBeUndefined();
+  });
+});
+
+describe("loadConfig", () => {
+  it("should load a config", () => {
+    const config = { compilerOptions: { baseUrl: "hej" } };
+    const res = loadTsconfig(
+      "/root/dir1/tsconfig.json",
+      (path) => path === "/root/dir1/tsconfig.json",
+      (_) => JSON.stringify(config)
+    );
+    expect(res).toStrictEqual(config);
+  });
+
+  it("should load a config with comments", () => {
+    const config = { compilerOptions: { baseUrl: "hej" } };
+    const res = loadTsconfig(
+      "/root/dir1/tsconfig.json",
+      (path) => path === "/root/dir1/tsconfig.json",
+      (_) => `{
+          // my comment
+          "compilerOptions": { 
+            "baseUrl": "hej"
+          }
+        }`
+    );
+    expect(res).toStrictEqual(config);
+  });
+
+  it("should load a config with trailing commas", () => {
+    const config = { compilerOptions: { baseUrl: "hej" } };
+    const res = loadTsconfig(
+      "/root/dir1/tsconfig.json",
+      (path) => path === "/root/dir1/tsconfig.json",
+      (_) => `{
+          "compilerOptions": { 
+            "baseUrl": "hej",
+          },
+        }`
+    );
+    expect(res).toStrictEqual(config);
+  });
+
+  it("should throw an error including the file path when encountering invalid JSON5", () => {
+    expect(() =>
+      loadTsconfig(
+        "/root/dir1/tsconfig.json",
+        (path) => path === "/root/dir1/tsconfig.json",
+        (_) => `{
+            "compilerOptions": {
+          }`
+      )
+    ).toThrowError(
+      "/root/dir1/tsconfig.json is malformed JSON5: invalid end of input at 3:12"
+    );
+  });
+
+  it("should load a config with string extends and overwrite all options", () => {
+    const firstConfig = {
+      extends: "../base-config.json",
+      compilerOptions: { baseUrl: "kalle", paths: { foo: ["bar2"] } },
+    };
+    const firstConfigPath = join("/root", "dir1", "tsconfig.json");
+    const baseConfig = {
+      compilerOptions: {
+        baseUrl: "olle",
+        paths: { foo: ["bar1"] },
+        strict: true,
+      },
+    };
+    const baseConfigPath = join("/root", "base-config.json");
+    const res = loadTsconfig(
+      join("/root", "dir1", "tsconfig.json"),
+      (path) => path === firstConfigPath || path === baseConfigPath,
+      (path) => {
+        if (path === firstConfigPath) {
+          return JSON.stringify(firstConfig);
+        }
+        if (path === baseConfigPath) {
+          return JSON.stringify(baseConfig);
+        }
+        return "";
+      }
+    );
+
+    expect(res).toEqual({
+      extends: "../base-config.json",
+      compilerOptions: {
+        baseUrl: "kalle",
+        paths: { foo: ["bar2"] },
+        strict: true,
+      },
+    });
+  });
+
+  it("should load a config with string extends from node_modules and overwrite all options", () => {
+    const firstConfig = {
+      extends: "my-package/base-config.json",
+      compilerOptions: { baseUrl: "kalle", paths: { foo: ["bar2"] } },
+    };
+    const firstConfigPath = join("/root", "dir1", "tsconfig.json");
+    const baseConfig = {
+      compilerOptions: {
+        baseUrl: "olle",
+        paths: { foo: ["bar1"] },
+        strict: true,
+      },
+    };
+    const baseConfigPath = join(
+      "/root",
+      "dir1",
+      "node_modules",
+      "my-package",
+      "base-config.json"
+    );
+    const res = loadTsconfig(
+      join("/root", "dir1", "tsconfig.json"),
+      (path) => path === firstConfigPath || path === baseConfigPath,
+      (path) => {
+        if (path === firstConfigPath) {
+          return JSON.stringify(firstConfig);
+        }
+        if (path === baseConfigPath) {
+          return JSON.stringify(baseConfig);
+        }
+        return "";
+      }
+    );
+
+    expect(res).toEqual({
+      extends: "my-package/base-config.json",
+      compilerOptions: {
+        baseUrl: "kalle",
+        paths: { foo: ["bar2"] },
+        strict: true,
+      },
+    });
+  });
+
+  it("should use baseUrl relative to location of extended tsconfig", () => {
+    const firstConfig = { compilerOptions: { baseUrl: "." } };
+    const firstConfigPath = join("/root", "first-config.json");
+    const secondConfig = { extends: "../first-config.json" };
+    const secondConfigPath = join("/root", "dir1", "second-config.json");
+    const thirdConfig = { extends: "../second-config.json" };
+    const thirdConfigPath = join("/root", "dir1", "dir2", "third-config.json");
+    const res = loadTsconfig(
+      join("/root", "dir1", "dir2", "third-config.json"),
+      (path) =>
+        path === firstConfigPath ||
+        path === secondConfigPath ||
+        path === thirdConfigPath,
+      (path) => {
+        if (path === firstConfigPath) {
+          return JSON.stringify(firstConfig);
+        }
+        if (path === secondConfigPath) {
+          return JSON.stringify(secondConfig);
+        }
+        if (path === thirdConfigPath) {
+          return JSON.stringify(thirdConfig);
+        }
+        return "";
+      }
+    );
+
+    expect(res).toEqual({
+      extends: "../second-config.json",
+      compilerOptions: { baseUrl: join("..", "..") },
+    });
+  });
+
+  it("should load a config with array extends and overwrite all options", () => {
+    const baseConfig1 = {
+      compilerOptions: { baseUrl: ".", paths: { foo: ["bar"] } },
+    };
+    const baseConfig1Path = join("/root", "base-config-1.json");
+    const baseConfig2 = { compilerOptions: { baseUrl: "." } };
+    const baseConfig2Path = join("/root", "dir1", "base-config-2.json");
+    const baseConfig3 = {
+      compilerOptions: { baseUrl: ".", paths: { foo: ["bar2"] } },
+    };
+    const baseConfig3Path = join("/root", "dir1", "dir2", "base-config-3.json");
+    const actualConfig = {
+      extends: [
+        "./base-config-1.json",
+        "./dir1/base-config-2.json",
+        "./dir1/dir2/base-config-3.json",
+      ],
+    };
+    const actualConfigPath = join("/root", "tsconfig.json");
+
+    const res = loadTsconfig(
+      join("/root", "tsconfig.json"),
+      (path) =>
+        [
+          baseConfig1Path,
+          baseConfig2Path,
+          baseConfig3Path,
+          actualConfigPath,
+        ].indexOf(path) >= 0,
+      (path) => {
+        if (path === baseConfig1Path) {
+          return JSON.stringify(baseConfig1);
+        }
+        if (path === baseConfig2Path) {
+          return JSON.stringify(baseConfig2);
+        }
+        if (path === baseConfig3Path) {
+          return JSON.stringify(baseConfig3);
+        }
+        if (path === actualConfigPath) {
+          return JSON.stringify(actualConfig);
+        }
+        return "";
+      }
+    );
+
+    expect(res).toEqual({
+      extends: [
+        "./base-config-1.json",
+        "./dir1/base-config-2.json",
+        "./dir1/dir2/base-config-3.json",
+      ],
+      compilerOptions: {
+        baseUrl: join("dir1", "dir2"),
+        paths: { foo: ["bar2"] },
+      },
+    });
+  });
+
+  it("should load a config with array extends without .json extension", () => {
+    const baseConfig = {
+      compilerOptions: { baseUrl: ".", paths: { foo: ["bar"] } },
+    };
+    const baseConfigPath = join("/root", "base-config-1.json");
+    const actualConfig = { extends: ["./base-config-1"] };
+    const actualConfigPath = join("/root", "tsconfig.json");
+
+    const res = loadTsconfig(
+      join("/root", "tsconfig.json"),
+      (path) => [baseConfigPath, actualConfigPath].indexOf(path) >= 0,
+      (path) => {
+        if (path === baseConfigPath) {
+          return JSON.stringify(baseConfig);
+        }
+        if (path === actualConfigPath) {
+          return JSON.stringify(actualConfig);
+        }
+        return "";
+      }
+    );
+
+    expect(res).toEqual({
+      extends: ["./base-config-1"],
+      compilerOptions: {
+        baseUrl: ".",
+        paths: { foo: ["bar"] },
+      },
+    });
+  });
+});

package/backend/node_modules/tsconfig-paths/src/__tests__/tsconfig-named.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../base-tsconfig.json",
+  "compilerOptions": {
+    "baseUrl": ".",
+    "module": "commonjs",
+    "target": "es6",
+    "sourceMap": true,
+    "outDir": "./js_out"
+  }
+}

package/backend/node_modules/tsconfig-paths/src/config-loader.ts

@@ -0,0 +1,89 @@
+import * as TsConfigLoader2 from "./tsconfig-loader";
+import * as path from "path";
+
+export interface ExplicitParams {
+  baseUrl: string;
+  paths: { [key: string]: Array<string> };
+  mainFields?: (string | string[])[];
+  addMatchAll?: boolean;
+}
+
+export type TsConfigLoader = (
+  params: TsConfigLoader2.TsConfigLoaderParams
+) => TsConfigLoader2.TsConfigLoaderResult;
+
+export interface ConfigLoaderParams {
+  cwd: string;
+  explicitParams?: ExplicitParams;
+  tsConfigLoader?: TsConfigLoader;
+}
+
+export interface ConfigLoaderSuccessResult {
+  resultType: "success";
+  configFileAbsolutePath: string;
+  baseUrl?: string;
+  absoluteBaseUrl: string;
+  paths: { [key: string]: Array<string> };
+  mainFields?: (string | string[])[];
+  addMatchAll?: boolean;
+}
+
+export interface ConfigLoaderFailResult {
+  resultType: "failed";
+  message: string;
+}
+
+export type ConfigLoaderResult =
+  | ConfigLoaderSuccessResult
+  | ConfigLoaderFailResult;
+
+export function loadConfig(cwd: string = process.cwd()): ConfigLoaderResult {
+  return configLoader({ cwd });
+}
+
+export function configLoader({
+  cwd,
+  explicitParams,
+  tsConfigLoader = TsConfigLoader2.tsConfigLoader,
+}: ConfigLoaderParams): ConfigLoaderResult {
+  if (explicitParams) {
+    const absoluteBaseUrl = path.isAbsolute(explicitParams.baseUrl)
+      ? explicitParams.baseUrl
+      : path.join(cwd, explicitParams.baseUrl);
+
+    return {
+      resultType: "success",
+      configFileAbsolutePath: "",
+      baseUrl: explicitParams.baseUrl,
+      absoluteBaseUrl,
+      paths: explicitParams.paths,
+      mainFields: explicitParams.mainFields,
+      addMatchAll: explicitParams.addMatchAll,
+    };
+  }
+
+  // Load tsconfig and create path matching function
+  const loadResult = tsConfigLoader({
+    cwd,
+    getEnv: (key: string) => process.env[key],
+  });
+
+  if (!loadResult.tsConfigPath) {
+    return {
+      resultType: "failed",
+      message: "Couldn't find tsconfig.json",
+    };
+  }
+
+  return {
+    resultType: "success",
+    configFileAbsolutePath: loadResult.tsConfigPath,
+    baseUrl: loadResult.baseUrl,
+    absoluteBaseUrl: path.resolve(
+      path.dirname(loadResult.tsConfigPath),
+      loadResult.baseUrl || ""
+    ),
+    paths: loadResult.paths || {},
+    addMatchAll: loadResult.baseUrl !== undefined,
+  };
+}

package/backend/node_modules/tsconfig-paths/src/filesystem.ts

@@ -0,0 +1,93 @@
+import * as fs from "fs";
+
+/**
+ * Typing for the fields of package.json we care about
+ */
+export interface PackageJson {
+  [key: string]: string | PackageJson;
+}
+
+/**
+ * A function that json from a file
+ */
+export interface ReadJsonSync {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  (packageJsonPath: string): any | undefined;
+}
+
+export interface FileExistsSync {
+  (name: string): boolean;
+}
+
+export interface FileExistsAsync {
+  (path: string, callback: (err?: Error, exists?: boolean) => void): void;
+}
+
+export interface ReadJsonAsyncCallback {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  (err?: Error, content?: any): void;
+}
+
+export interface ReadJsonAsync {
+  (path: string, callback: ReadJsonAsyncCallback): void;
+}
+
+export function fileExistsSync(path: string): boolean {
+  // If the file doesn't exist, avoid throwing an exception over the native barrier for every miss
+  if (!fs.existsSync(path)) {
+    return false;
+  }
+  try {
+    const stats = fs.statSync(path);
+    return stats.isFile();
+  } catch (err) {
+    // If error, assume file did not exist
+    return false;
+  }
+}
+
+/**
+ * Reads package.json from disk
+ *
+ * @param file Path to package.json
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function readJsonFromDiskSync(packageJsonPath: string): any | undefined {
+  if (!fs.existsSync(packageJsonPath)) {
+    return undefined;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-require-imports
+  return require(packageJsonPath);
+}
+
+export function readJsonFromDiskAsync(
+  path: string,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  callback: (err?: Error, content?: any) => void
+): void {
+  fs.readFile(path, "utf8", (err, result) => {
+    // If error, assume file did not exist
+    if (err || !result) {
+      return callback();
+    }
+    const json = JSON.parse(result);
+    return callback(undefined, json);
+  });
+}
+
+export function fileExistsAsync(
+  path2: string,
+  callback2: (err?: Error, exists?: boolean) => void
+): void {
+  fs.stat(path2, (err: Error, stats: fs.Stats) => {
+    if (err) {
+      // If error assume file does not exist
+      return callback2(undefined, false);
+    }
+    callback2(undefined, stats ? stats.isFile() : false);
+  });
+}
+
+export function removeExtension(path: string): string {
+  return path.substring(0, path.lastIndexOf(".")) || path;
+}

package/backend/node_modules/tsconfig-paths/src/index.ts

@@ -0,0 +1,24 @@
+// register is used from register.js in root dir
+export {
+  createMatchPath,
+  matchFromAbsolutePaths,
+  MatchPath,
+} from "./match-path-sync";
+export {
+  createMatchPathAsync,
+  matchFromAbsolutePathsAsync,
+  MatchPathAsync,
+} from "./match-path-async";
+export { register } from "./register";
+export {
+  loadConfig,
+  ConfigLoaderResult,
+  ConfigLoaderSuccessResult,
+  ConfigLoaderFailResult,
+} from "./config-loader";
+export {
+  ReadJsonSync,
+  ReadJsonAsync,
+  FileExistsSync,
+  FileExistsAsync,
+} from "./filesystem";

package/backend/node_modules/tsconfig-paths/src/mapping-entry.ts

@@ -0,0 +1,65 @@
+import * as path from "path";
+
+export interface MappingEntry {
+  readonly pattern: string;
+  readonly paths: ReadonlyArray<string>;
+}
+
+export interface Paths {
+  readonly [key: string]: ReadonlyArray<string>;
+}
+
+/**
+ * Converts an absolute baseUrl and paths to an array of absolute mapping entries.
+ * The array is sorted by longest prefix.
+ * Having an array with entries allows us to keep a sorting order rather than
+ * sort by keys each time we use the mappings.
+ *
+ * @param absoluteBaseUrl
+ * @param paths
+ * @param addMatchAll
+ */
+export function getAbsoluteMappingEntries(
+  absoluteBaseUrl: string,
+  paths: Paths,
+  addMatchAll: boolean
+): ReadonlyArray<MappingEntry> {
+  // Resolve all paths to absolute form once here, and sort them by
+  // longest prefix once here, this saves time on each request later.
+  // We need to put them in an array to preserve the sorting order.
+  const sortedKeys = sortByLongestPrefix(Object.keys(paths));
+  const absolutePaths: Array<MappingEntry> = [];
+  for (const key of sortedKeys) {
+    absolutePaths.push({
+      pattern: key,
+      paths: paths[key].map((pathToResolve) =>
+        path.resolve(absoluteBaseUrl, pathToResolve)
+      ),
+    });
+  }
+  // If there is no match-all path specified in the paths section of tsconfig, then try to match
+  // all paths relative to baseUrl, this is how typescript works.
+  if (!paths["*"] && addMatchAll) {
+    absolutePaths.push({
+      pattern: "*",
+      paths: [`${absoluteBaseUrl.replace(/\/$/, "")}/*`],
+    });
+  }
+
+  return absolutePaths;
+}
+
+/**
+ * Sort path patterns.
+ * If a module name can be matched with multiple patterns then pattern with the longest prefix will be picked.
+ */
+function sortByLongestPrefix(arr: Array<string>): Array<string> {
+  return arr
+    .concat()
+    .sort((a: string, b: string) => getPrefixLength(b) - getPrefixLength(a));
+}
+
+function getPrefixLength(pattern: string): number {
+  const prefixLength = pattern.indexOf("*");
+  return pattern.substr(0, prefixLength).length;
+}