add support for resetting lock files

Author: ammarahm-ed

type-gen/src/cli/index.ts

@@ -3,8 +3,8 @@ import * as fs from "fs";
 import { generateTypes } from "..";
 import { CliArgumentsMap } from "../types";
 import { sanitizeFileName } from "../utils";
-import path = require("path");
 import { resolvePackageJSONPath } from "@rigor789/resolve-package-path";
+import path = require("path");
 
 const args = process.argv.slice(2);
 const workDir = process.cwd();
@@ -26,6 +26,7 @@ Options:
     -c | --core: Generate types for @nativescript/core.
     -a | --all: Generate types for all packages based on project dependencies.
     -d | --directory: Generate types from a directory.
+    -r | --reset: Reset lock files
     -n | --filename: Name of the output file.
     -h | --help: Show help.    
 `);
@@ -54,6 +55,10 @@ function parseArgs(args: any[]) {
       case "--output":
         parsedArgs.output = _args[i + 1];
         break;
+      case "-r":
+      case "--reset":
+        parsedArgs.resetLockFiles = true;
+        break;
       case "-f":
       case "--framework":
         parsedArgs.framework = _args[i + 1];
@@ -82,23 +87,23 @@ function parseArgs(args: any[]) {
 const parsedArgs = parseArgs(args);
 
 const isNativeScriptInstalled = resolvePackageJSONPath("@nativescript/core", {
-  paths: [workDir]
-})
+  paths: [workDir],
+});
 
 if (!isNativeScriptInstalled) {
   console.error("Please install @nativescript/core in your project.");
   process.exit(1);
 }
 
-if (!parsedArgs.package && !parsedArgs.core && !parsedArgs.all) {
-  console.error("Please provide a package to generate types for.");
-  process.exit(1);
-}
+// if (!parsedArgs.package && !parsedArgs.core && !parsedArgs.all) {
+//   console.error("Please provide a package to generate types for.");
+//   process.exit(1);
+// }
 
 if (parsedArgs.package) {
   const isPackageInstalled = resolvePackageJSONPath(parsedArgs.package, {
-  paths: [workDir]
-});
+    paths: [workDir],
+  });
   if (!isPackageInstalled) {
     console.error(
       `Package ${parsedArgs.package} is not installed in your project.`
@@ -107,40 +112,106 @@ if (parsedArgs.package) {
   }
 }
 
-if (!parsedArgs.framework) {
-  console.error(
-    "Invalid framework provided. The framework to generate the types for. (solidjs | vue | svelte | angular | react)."
-  );
-  process.exit(1);
-}
+const typegenLockDir = path.join(workDir, "node_modules", ".ns-type-gen");
+const lockFilePath = path.join(typegenLockDir, ".ns-type-gen.lock.json");
 
-export async function startCliTypeGenerator() {
+async function generateTypesForArgs(parsedArgs: CliArgumentsMap) {
   const types = await generateTypes(parsedArgs);
   if (types?.length) {
     for (let type of types) {
       const filename = parsedArgs.filename
         ? `${parsedArgs.filename}`
         : `${
-            parsedArgs.package
-              ? sanitizeFileName(parsedArgs.package)
-              : parsedArgs.core
+            parsedArgs.core
               ? "core"
-              : "ns"
+              : parsedArgs.package
+                ? sanitizeFileName(parsedArgs.package)
+                : "ns"
           }_${parsedArgs.framework}_${type.nameSuffix}.${type.format}`;
 
-          
       if (parsedArgs.output && !fs.existsSync(parsedArgs.output)) {
         fs.mkdirSync(parsedArgs.output, {
-          recursive: true
-        })
+          recursive: true,
+        });
       }
 
       fs.writeFileSync(
-        parsedArgs.output ? `${parsedArgs.output}/${filename}` : `types/${filename}`,
+        parsedArgs.output
+          ? `${parsedArgs.output}/${filename}`
+          : `types/${filename}`,
         type.data
       );
     }
   }
 }
 
+export async function startCliTypeGenerator() {
+  if (parsedArgs.resetLockFiles) {
+    if (fs.existsSync(lockFilePath)) {
+      fs.unlinkSync(lockFilePath);
+      console.log("Lock files have been reset.");
+    }
+  }
+
+  if (
+    !parsedArgs.all &&
+    !parsedArgs.core &&
+    !parsedArgs.directory &&
+    !parsedArgs.package
+  ) {
+    return;
+  }
+    
+
+  if (!parsedArgs.framework) {
+    console.error(
+      "Invalid framework provided. The framework to generate the types for. (solid | vue | svelte | angular | react)."
+    );
+    process.exit(1);
+  }
+
+  if (parsedArgs.all) {
+    const packageJsonPath = path.join(workDir, "package.json");
+    if (!fs.existsSync(packageJsonPath)) {
+      console.log(
+        "Could not find a valid package.json file at the current directory to generate types"
+      );
+      return;
+    }
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+
+    let lockFileJson: Record<string, string> = undefined;
+    try {
+      if (fs.existsSync(lockFilePath)) {
+        lockFileJson = JSON.parse(fs.readFileSync(lockFilePath, "utf-8"));
+      }
+    } catch (e) {}
+
+    const packages = packageJson.dependencies as Record<string, string>;
+    if (!packages) {
+      console.log(
+        "The provided package.json file is invalid or does not have a dependencies key."
+      );
+      return;
+    }
+    const packageNames = Object.keys(packages);
+    for (const pkgName of packageNames) {
+      if (!lockFileJson || lockFileJson[pkgName] !== packages[pkgName]) {
+        await generateTypesForArgs({
+          ...parsedArgs,
+          package: pkgName,
+          core: pkgName === "@nativescript/core",
+        });
+      }
+    }
+
+    if (!fs.existsSync(typegenLockDir)) {
+      fs.mkdirSync(typegenLockDir);
+    }
+    fs.writeFileSync(lockFilePath, JSON.stringify(packages));
+  } else {
+    await generateTypesForArgs(parsedArgs);
+  }
+}
+
 startCliTypeGenerator();

type-gen/src/index.ts

@@ -23,7 +23,7 @@ import { generateSolidTypes } from "./generators/solid";
 import { generateVueTypes } from "./generators/vue";
 import { generateSvelteTypes } from "./generators/svelte";
 import { generateReactTypes } from "./generators/react";
-const { resolvePackagePath } = require("@rigor789/resolve-package-path");
+import { resolvePackageJSONPath } from "@rigor789/resolve-package-path";
 
 async function visitFilesForSource(
   source: string,
@@ -32,13 +32,14 @@ async function visitFilesForSource(
   viewVisitor?: (view: Partial<InputFile>) => void
 ) {
   const sourceModulePath = isModule
-    ? //@ts-ignore
-      path.dirname(resolvePackagePath(source, {
-        paths: [process.cwd()]
-      }))
+    ? path.dirname(
+        resolvePackageJSONPath(source, {
+          paths: [process.cwd()],
+        })
+      )
     : path.join(__dirname, source);
 
-  const globPattern = path.join(sourceModulePath, pattern);
+  const globPattern = path.join(sourceModulePath.replace("package.json", ""), pattern);
   const files = await glob(globPattern);
 
   for (let file of files) {
@@ -115,7 +116,6 @@ export async function getMetadataFromPath(
     tags: [],
   };
 
-
   // Append all entries into a single entry
   for (let entry of jsonEntries) {
     //@ts-ignore
@@ -154,13 +154,18 @@ export async function generateTypes(
       : args.directory;
 
   if (!root) return [];
-
   const rawData = await getMetadataFromPath(
     root,
     "**/*.ts",
     args.directory ? false : true
   );
 
+  if (!rawData.tags.length) {
+    console.log("No NativeScript views found in", root);
+    return [];
+  }
+
+  console.log(rawData.tags.length, "views found in", root);
 
   switch (args.framework) {
     case "angular":

type-gen/src/types.ts

@@ -337,6 +337,7 @@ export type CliArgumentsMap = {
   all?: boolean;
   filename?: string;
   directory?: string;
+  resetLockFiles?: boolean;
 };
 
 export type InputFile = {