tstyche 1.0.0-beta.4 → 1.0.0-beta.6

package/CHANGELOG.md

@@ -1,5 +1,30 @@
 # Changelog
 
+## [1.0.0-beta.6] - 2023-12-03
+
+### Added
+
+- **New!** Add `.toHaveProperty()` matcher ([#36](https://github.com/tstyche/tstyche/pull/36))
+
+### Fixed
+
+- Accept template literals as arguments of the `.toRaiseError()` matcher ([#38](https://github.com/tstyche/tstyche/pull/38))
+
+## [1.0.0-beta.5] - 2023-11-27
+
+### Changed
+
+- **Breaking!** Move retry logic to the `Lock` class ([#31](https://github.com/tstyche/tstyche/pull/31))
+- Bring back support for Node.js 16 ([#28](https://github.com/tstyche/tstyche/pull/28), [#27](https://github.com/tstyche/tstyche/pull/27))
+
+### Added
+
+- **New!** Add support for the `current` target tag ([#33](https://github.com/tstyche/tstyche/pull/33))
+
+### Fixed
+
+- Allow `.raiseError()` to take template literals as arguments ([#35](https://github.com/tstyche/tstyche/pull/35))
+
 ## [1.0.0-beta.4] - 2023-11-24
 
 ### Added
@@ -8,9 +33,9 @@
 
 ### Removed
 
-- **Breaking:** Remove the `context()` helper ([#24](https://github.com/tstyche/tstyche/pull/24))
-- **Breaking:** Drop support for Node.js 16 ([#22](https://github.com/tstyche/tstyche/pull/22))
-- **Breaking:** Rename methods of the `StoreService` class ([`5d74201`](https://github.com/tstyche/tstyche/commit/5d74201))
+- **Breaking!** Remove the `context()` helper ([#24](https://github.com/tstyche/tstyche/pull/24))
+- **Breaking!** Drop support for Node.js 16 ([#22](https://github.com/tstyche/tstyche/pull/22))
+- **Breaking!** Rename methods of the `StoreService` class ([`5d74201`](https://github.com/tstyche/tstyche/commit/5d74201))
 
 ### Fixed
 
@@ -40,6 +65,8 @@
 
 _First pre-release._
 
+[1.0.0-beta.6]: https://github.com/tstyche/tstyche/releases/tag/v1.0.0-beta.6
+[1.0.0-beta.5]: https://github.com/tstyche/tstyche/releases/tag/v1.0.0-beta.5
 [1.0.0-beta.4]: https://github.com/tstyche/tstyche/releases/tag/v1.0.0-beta.4
 [1.0.0-beta.3]: https://github.com/tstyche/tstyche/releases/tag/v1.0.0-beta.3
 [1.0.0-beta.2]: https://github.com/tstyche/tstyche/releases/tag/v1.0.0-beta.2

package/README.md

@@ -56,9 +56,10 @@ test("handles numbers", () => {
 
 Here is the list of all matchers:
 
-- `.toBeAssignable()`, `.toEqual()`, `.toMatch()` compares types or types of expression;
-- `.toRaiseError()` captures the error message or code;
-- `.toBeString()`, `.toBeNumber()`, `.toBeVoid()` and 9 more checks for primitive types.
+- `.toBeAssignable()`, `.toEqual()`, `.toMatch()` compares types or types of expression,
+- `.toHaveProperty()` looks up keys on an object type,
+- `.toRaiseError()` captures the type error message or code,
+- `.toBeString()`, `.toBeNumber()`, `.toBeVoid()` and 9 more shorthand checks for primitive types.
 
 ## Runner
 

package/build/index.d.cts

@@ -133,6 +133,10 @@ interface Matchers {
          */
         (target: unknown): void;
     };
+    /**
+     * Checks if a property key exists on the source type.
+     */
+    toHaveProperty: (key: string | number | symbol) => void;
     /**
      * Checks if the target type is a subtype the source type.
      */

package/build/index.d.ts

@@ -133,6 +133,10 @@ interface Matchers {
          */
         (target: unknown): void;
     };
+    /**
+     * Checks if a property key exists on the source type.
+     */
+    toHaveProperty: (key: string | number | symbol) => void;
     /**
      * Checks if the target type is a subtype the source type.
      */

package/build/tstyche.js

@@ -5,7 +5,7 @@ import path from 'node:path';
 import fs from 'node:fs/promises';
 import { createRequire } from 'node:module';
 import { spawn } from 'node:child_process';
-import { setInterval } from 'node:timers/promises';
+import https from 'node:https';
 
 class EventEmitter {
     static #handlers = new Set();
@@ -1396,7 +1396,10 @@ class IdentifierLookup {
         };
     }
     clone() {
-        return structuredClone(this.#identifiers);
+        return {
+            namedImports: { ...this.#identifiers.namedImports },
+            namespace: this.#identifiers.namespace,
+        };
     }
     handleImportDeclaration(node) {
         if (this.#moduleSpecifiers.includes(node.moduleSpecifier.getText()) &&
@@ -1508,6 +1511,7 @@ class CollectService {
         "toBeUnknown",
         "toBeVoid",
         "toEqual",
+        "toHaveProperty",
         "toMatch",
         "toRaiseError",
     ];
@@ -1679,8 +1683,12 @@ class Checker {
     #assertNonNullishTypeChecker(assertion) {
         this.#assertNonNullish(assertion.typeChecker, "The 'typeChecker' was not provided.");
     }
+    #assertStringsOrNumber(expression) {
+        return (expression != null &&
+            (this.compiler.isStringLiteralLike(expression) || this.compiler.isNumericLiteral(expression)));
+    }
     #assertStringsOrNumbers(nodes) {
-        return nodes.every((expression) => this.compiler.isStringLiteral(expression) || this.compiler.isNumericLiteral(expression));
+        return nodes.every((expression) => this.#assertStringsOrNumber(expression));
     }
     explain(assertion) {
         this.#assertNonNullishTypeChecker(assertion);
@@ -1738,6 +1746,26 @@ class Checker {
                         : `Type '${targetTypeText}' is not identical to type '${sourceTypeText}'.`, origin),
                 ];
             }
+            case "toHaveProperty": {
+                this.#assertNonNullishSourceType(assertion);
+                this.#assertNonNullishTargetType(assertion);
+                const sourceText = assertion.typeChecker.typeToString(assertion.sourceType.type);
+                let targetArgumentText;
+                if (assertion.targetType.type.flags & this.compiler.TypeFlags.StringOrNumberLiteral) {
+                    targetArgumentText = String(assertion.targetType.type.value);
+                }
+                else if (assertion.targetType.type.flags & this.compiler.TypeFlags.UniqueESSymbol) {
+                    targetArgumentText = `[${this.compiler.unescapeLeadingUnderscores(assertion.targetType.type.symbol.escapedName)}]`;
+                }
+                else {
+                    throw new Error("An argument for 'key' must be of type 'string | number | symbol'.");
+                }
+                return [
+                    Diagnostic.error(assertion.isNot
+                        ? `Property '${targetArgumentText}' exists on type '${sourceText}'.`
+                        : `Property '${targetArgumentText}' does not exist on type '${sourceText}'.`, origin),
+                ];
+            }
             case "toMatch": {
                 this.#assertNonNullishSourceType(assertion);
                 this.#assertNonNullishTargetType(assertion);
@@ -1791,7 +1819,7 @@ class Checker {
                     }
                     const isMatch = this.#matchExpectedError(diagnostic, argument);
                     if (!assertion.isNot && !isMatch) {
-                        const expectedText = this.compiler.isStringLiteral(argument)
+                        const expectedText = this.compiler.isStringLiteralLike(argument)
                             ? `matching substring '${argument.text}'`
                             : `with code ${argument.text}`;
                         const related = [
@@ -1801,7 +1829,7 @@ class Checker {
                         diagnostics.push(Diagnostic.error(`${sourceText} did not raise a type error ${expectedText}.`, origin).add({ related }));
                     }
                     if (assertion.isNot && isMatch) {
-                        const expectedText = this.compiler.isStringLiteral(argument)
+                        const expectedText = this.compiler.isStringLiteralLike(argument)
                             ? `matching substring '${argument.text}'`
                             : `with code ${argument.text}`;
                         const related = [
@@ -1887,6 +1915,27 @@ class Checker {
                 this.#assertNonNullish(assertion.typeChecker?.isTypeIdenticalTo, "The 'isTypeIdenticalTo' method is missing in the provided type checker.");
                 return assertion.typeChecker.isTypeIdenticalTo(assertion.sourceType.type, assertion.targetType.type);
             }
+            case "toHaveProperty": {
+                this.#assertNonNullishSourceType(assertion);
+                this.#assertNonNullishTargetType(assertion);
+                if (!(assertion.sourceType.type.flags & this.compiler.TypeFlags.StructuredType)) {
+                    const receivedText = assertion.typeChecker?.typeToString(assertion.sourceType.type);
+                    throw new Error(`An argument for 'source' must be of object type, received: '${receivedText}'.`);
+                }
+                let targetArgumentText;
+                if (assertion.targetType.type.flags & this.compiler.TypeFlags.StringOrNumberLiteral) {
+                    targetArgumentText = String(assertion.targetType.type.value);
+                }
+                else if (assertion.targetType.type.flags & this.compiler.TypeFlags.UniqueESSymbol) {
+                    targetArgumentText = this.compiler.unescapeLeadingUnderscores(assertion.targetType.type.escapedName);
+                }
+                else {
+                    throw new Error("An argument for 'key' must be of type 'string | number | symbol'.");
+                }
+                return assertion.sourceType.type.getProperties().some((property) => {
+                    return this.compiler.unescapeLeadingUnderscores(property.escapedName) === targetArgumentText;
+                });
+            }
             case "toMatch": {
                 this.#assertNonNullishSourceType(assertion);
                 this.#assertNonNullishTargetType(assertion);
@@ -1904,7 +1953,7 @@ class Checker {
                     return false;
                 }
                 return assertion.targetArguments.every((expectedArgument, index) => {
-                    if (this.compiler.isStringLiteral(expectedArgument)) {
+                    if (this.compiler.isStringLiteralLike(expectedArgument)) {
                         return this.compiler
                             .flattenDiagnosticMessageText(assertion.diagnostics[index]?.messageText, " ", 0)
                             .includes(expectedArgument.text);
@@ -1920,7 +1969,7 @@ class Checker {
         }
     }
     #matchExpectedError(diagnostic, argument) {
-        if (this.compiler.isStringLiteral(argument)) {
+        if (this.compiler.isStringLiteralLike(argument)) {
             return this.compiler.flattenDiagnosticMessageText(diagnostic.messageText, " ", 0).includes(argument.text);
         }
         if (this.compiler.isNumericLiteral(argument)) {
@@ -2330,7 +2379,7 @@ class OptionDefinitionsMap {
             items: {
                 brand: "string",
                 name: "target",
-                pattern: "^([45]\\.[0-9](\\.[0-9])?)|beta|latest|next|rc$",
+                pattern: "^([45]\\.[0-9](\\.[0-9])?)|beta|current|latest|next|rc$",
             },
             name: "target",
         },
@@ -2426,7 +2475,7 @@ class OptionUsageText {
                 const supportedTagsText = `Supported tags: ${["'", supportedTags.join("', '"), "'"].join("")}.`;
                 switch (this.#optionGroup) {
                     case 2:
-                        usageText.push("Argument for the '--target' option must be a single tag or a comma separated list of versions.", "Usage examples: '--target 4.9', '--target 5.0.4', '--target 4.7,4.8,latest'.", supportedTagsText);
+                        usageText.push("Argument for the '--target' option must be a single tag or a comma separated list.", "Usage examples: '--target 4.9', '--target 5.0.4', '--target 4.7,4.8,latest'.", supportedTagsText);
                         break;
                     case 4:
                         usageText.push("Item of the 'target' list must be a supported version tag.", supportedTagsText);
@@ -2916,58 +2965,85 @@ class Lock {
     #lockFilePath;
     static #lockSuffix = "__lock__";
     constructor(targetPath) {
-        this.#lockFilePath = Lock.getLockFilePath(targetPath);
+        this.#lockFilePath = Lock.#getLockFilePath(targetPath);
         writeFileSync(this.#lockFilePath, "");
         process.on("exit", () => {
             this.release();
         });
     }
-    static getLockFilePath(targetPath) {
+    static #getLockFilePath(targetPath) {
         return `${targetPath}${Lock.#lockSuffix}`;
     }
-    static isLocked(targetPath) {
-        return existsSync(Lock.getLockFilePath(targetPath));
+    static async isLocked(targetPath, options) {
+        let isLocked = existsSync(Lock.#getLockFilePath(targetPath));
+        if (!isLocked) {
+            return isLocked;
+        }
+        if (options?.timeout == null) {
+            return isLocked;
+        }
+        const waitStartTime = Date.now();
+        while (isLocked) {
+            if (options.signal?.aborted === true) {
+                break;
+            }
+            if (Date.now() - waitStartTime > options.timeout) {
+                options.onDiagnostic?.(`Lock wait timeout of ${options.timeout / 1000}s was exceeded.`);
+                break;
+            }
+            await Lock.#sleep(1000);
+            isLocked = existsSync(Lock.#getLockFilePath(targetPath));
+        }
+        return isLocked;
     }
     release() {
         rmSync(this.#lockFilePath, { force: true });
     }
+    static async #sleep(time) {
+        return new Promise((resolve) => setTimeout(resolve, time));
+    }
 }
 
 class CompilerModuleWorker {
     #cachePath;
+    #onDiagnostic;
     #readyFileName = "__ready__";
     #timeout = Environment.timeout * 1000;
-    constructor(cachePath) {
+    constructor(cachePath, onDiagnostic) {
         this.#cachePath = cachePath;
+        this.#onDiagnostic = onDiagnostic;
     }
     async ensure(compilerVersion, signal) {
         const installationPath = path.join(this.#cachePath, compilerVersion);
         const readyFilePath = path.join(installationPath, this.#readyFileName);
         const tsserverFilePath = path.join(installationPath, "node_modules", "typescript", "lib", "tsserverlibrary.js");
         const typescriptFilePath = path.join(installationPath, "node_modules", "typescript", "lib", "typescript.js");
-        if (Lock.isLocked(installationPath)) {
-            for await (const now of setInterval(1000, Date.now(), { signal })) {
-                const startTime = Date.now();
-                if (!Lock.isLocked(installationPath)) {
-                    break;
-                }
-                if (startTime - now > this.#timeout) {
-                    throw new Error(`Lock wait timeout of ${this.#timeout / 1000}s was exceeded.`);
-                }
-            }
+        if (await Lock.isLocked(installationPath, {
+            onDiagnostic: (text) => {
+                this.#onDiagnostic(Diagnostic.error([`Failed to install 'typescript@${compilerVersion}'.`, text]));
+            },
+            signal,
+            timeout: this.#timeout,
+        })) {
+            return;
         }
         if (existsSync(readyFilePath)) {
             return tsserverFilePath;
         }
         EventEmitter.dispatch(["store:info", { compilerVersion, installationPath: this.#normalizePath(installationPath) }]);
-        await fs.mkdir(installationPath, { recursive: true });
-        const lock = new Lock(installationPath);
-        await fs.writeFile(path.join(installationPath, "package.json"), this.#getPackageJson(compilerVersion));
-        await this.#installPackage(installationPath, signal);
-        await fs.writeFile(tsserverFilePath, await this.#getPatched(compilerVersion, tsserverFilePath));
-        await fs.writeFile(typescriptFilePath, await this.#getPatched(compilerVersion, typescriptFilePath));
-        await fs.writeFile(readyFilePath, "");
-        lock.release();
+        try {
+            await fs.mkdir(installationPath, { recursive: true });
+            const lock = new Lock(installationPath);
+            await fs.writeFile(path.join(installationPath, "package.json"), this.#getPackageJson(compilerVersion));
+            await this.#installPackage(installationPath, signal);
+            await fs.writeFile(tsserverFilePath, await this.#getPatched(compilerVersion, tsserverFilePath));
+            await fs.writeFile(typescriptFilePath, await this.#getPatched(compilerVersion, typescriptFilePath));
+            await fs.writeFile(readyFilePath, "");
+            lock.release();
+        }
+        catch (error) {
+            this.#onDiagnostic(Diagnostic.fromError(`Failed to install 'typescript@${compilerVersion}'.`, error));
+        }
         return tsserverFilePath;
     }
     #getPackageJson(version) {
@@ -3043,14 +3119,34 @@ class ManifestWorker {
         this.#prune = prune;
     }
     async #fetch(signal) {
-        const result = await fetch(new URL("typescript", this.#registryUrl), {
-            headers: { accept: "application/vnd.npm.install-v1+json; q=1.0, application/json; q=0.8, */*" },
-            signal,
+        return new Promise((resolve, reject) => {
+            const request = https.get(new URL("typescript", this.#registryUrl), {
+                headers: { accept: "application/vnd.npm.install-v1+json; q=1.0, application/json; q=0.8, */*" },
+                signal,
+            }, (result) => {
+                if (result.statusCode !== 200) {
+                    reject(new Error(`Request failed with status code ${String(result.statusCode)}.`));
+                    return;
+                }
+                result.setEncoding("utf8");
+                let rawData = "";
+                result.on("data", (chunk) => {
+                    rawData += chunk;
+                });
+                result.on("end", () => {
+                    try {
+                        const packageMetadata = JSON.parse(rawData);
+                        resolve(packageMetadata);
+                    }
+                    catch (error) {
+                        reject(error);
+                    }
+                });
+            });
+            request.on("error", (error) => {
+                reject(error);
+            });
         });
-        if (!result.ok) {
-            throw new Error(`Request failed with status code ${String(result.status)}.`);
-        }
-        return result.json();
     }
     isOutdated(manifest, ageTolerance = 0) {
         if (Date.now() - manifest.lastUpdated > 2 * 60 * 60 * 1000 + ageTolerance * 1000) {
@@ -3093,15 +3189,15 @@ class ManifestWorker {
             .sort();
         const minorVersions = [...new Set(manifest.versions.map((version) => version.slice(0, -2)))];
         for (const tag of minorVersions) {
-            const resolvedVersion = manifest.versions.findLast((version) => version.startsWith(tag));
+            const resolvedVersion = manifest.versions.filter((version) => version.startsWith(tag)).pop();
             if (resolvedVersion != null) {
                 manifest.resolutions[tag] = resolvedVersion;
             }
         }
-        for (const distributionTagKey of ["beta", "latest", "next", "rc"]) {
-            const distributionTagValue = packageMetadata["dist-tags"][distributionTagKey];
+        for (const tagKey of ["beta", "latest", "next", "rc"]) {
+            const distributionTagValue = packageMetadata["dist-tags"][tagKey];
             if (distributionTagValue != null) {
-                manifest.resolutions[distributionTagKey] = distributionTagValue;
+                manifest.resolutions[tagKey] = distributionTagValue;
             }
         }
         return manifest;
@@ -3171,7 +3267,7 @@ class StoreService {
     #nodeRequire = createRequire(import.meta.url);
     constructor() {
         this.#cachePath = Environment.storePath;
-        this.#compilerModuleWorker = new CompilerModuleWorker(this.#cachePath);
+        this.#compilerModuleWorker = new CompilerModuleWorker(this.#cachePath, this.#onDiagnostic);
         this.#manifestWorker = new ManifestWorker(this.#cachePath, async () => this.prune());
     }
     get supportedTags() {
@@ -3179,7 +3275,7 @@ class StoreService {
             this.#onDiagnostic(Diagnostic.error("Store manifest is not open. Call 'StoreService.open()' first."));
             return [];
         }
-        return [...Object.keys(this.#manifest.resolutions), ...this.#manifest.versions].sort();
+        return [...Object.keys(this.#manifest.resolutions), ...this.#manifest.versions, "current"].sort();
     }
     async install(tag, signal) {
         if (!this.#manifest) {
@@ -3191,14 +3287,7 @@ class StoreService {
             this.#onDiagnostic(Diagnostic.error(`Cannot add the 'typescript' package for the '${tag}' tag.`));
             return;
         }
-        let modulePath;
-        try {
-            modulePath = await this.#compilerModuleWorker.ensure(version, signal);
-        }
-        catch (error) {
-            this.#onDiagnostic(Diagnostic.fromError(`Failed to install 'typescript@${version}'.`, error));
-        }
-        return modulePath;
+        return this.#compilerModuleWorker.ensure(version, signal);
     }
     async load(tag, signal) {
         let modulePath;
@@ -3218,9 +3307,9 @@ class StoreService {
         }
         return;
     }
-    #onDiagnostic(diagnostic) {
+    #onDiagnostic = (diagnostic) => {
         EventEmitter.dispatch(["store:error", { diagnostics: [diagnostic] }]);
-    }
+    };
     async open(signal) {
         if (this.#manifest) {
             return;
@@ -3235,6 +3324,14 @@ class StoreService {
             this.#onDiagnostic(Diagnostic.error("Store manifest is not open. Call 'StoreService.open()' first."));
             return;
         }
+        if (tag === "current") {
+            try {
+                tag = this.#nodeRequire("typescript").version;
+            }
+            catch (error) {
+                this.#onDiagnostic(Diagnostic.fromError("Failed to resolve tag 'current'. The 'typescript' package might be not installed.", error));
+            }
+        }
         if (this.#manifest.versions.includes(tag)) {
             return tag;
         }
@@ -3260,7 +3357,7 @@ class StoreService {
             this.#onDiagnostic(Diagnostic.error("Store manifest is not open. Call 'StoreService.open()' first."));
             return false;
         }
-        if (this.#manifest.versions.includes(tag) || tag in this.#manifest.resolutions) {
+        if (this.#manifest.versions.includes(tag) || tag in this.#manifest.resolutions || tag === "current") {
             return true;
         }
         if (this.#manifest.resolutions["latest"] != null &&

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tstyche",
-  "version": "1.0.0-beta.4",
+  "version": "1.0.0-beta.6",
   "description": "The Essential Type Testing Tool.",
   "keywords": [
     "typescript",
@@ -57,14 +57,14 @@
   "devDependencies": {
     "@jest/globals": "29.7.0",
     "@rollup/plugin-typescript": "11.1.5",
-    "@types/node": "20.9.5",
-    "@typescript-eslint/eslint-plugin": "6.12.0",
-    "@typescript-eslint/parser": "6.12.0",
+    "@types/node": "20.10.2",
+    "@typescript-eslint/eslint-plugin": "6.13.1",
+    "@typescript-eslint/parser": "6.13.1",
     "ajv": "8.12.0",
     "c8": "8.0.1",
-    "cspell": "8.0.0",
-    "eslint": "8.54.0",
-    "eslint-config-prettier": "9.0.0",
+    "cspell": "8.1.0",
+    "eslint": "8.55.0",
+    "eslint-config-prettier": "9.1.0",
     "eslint-import-resolver-typescript": "3.6.1",
     "eslint-plugin-import": "2.29.0",
     "eslint-plugin-jest": "27.6.0",
@@ -76,7 +76,7 @@
     "jest-serializer-ansi-escapes": "2.0.1",
     "magic-string": "0.30.5",
     "prettier": "3.1.0",
-    "rollup": "4.5.2",
+    "rollup": "4.6.1",
     "rollup-plugin-dts": "6.1.0",
     "rollup-plugin-tsconfig-paths": "1.5.2",
     "ts-node": "10.9.1",
@@ -91,8 +91,8 @@
       "optional": true
     }
   },
-  "packageManager": "yarn@4.0.2",
+  "packageManager": "yarn@3.7.0",
   "engines": {
-    "node": "^18.12 || >=20.x"
+    "node": "^16.14 || 18.x || >=20.x"
   }
 }