datagrok-tools 4.14.0 → 4.14.2

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Datagrok-tools changelog
 
+## 4.14.2 (2025-05-16)
+
+### Features
+
+* Grok Link added path mode
+* Grok Link added unlink mode
+
 ## 4.14.0 (2025-05-12)
 
 ### Features

package/bin/commands/help.js

@@ -195,6 +195,8 @@ Link \`datagrok-api\` and libraries for local development
 
 Options:
 --dev               Links also dev dependencies
+--path              Instead of npm linking sets dependecies in package.json to local
+--unlink            Unlinks packages and sets last versions instead of local path in package.json dependecies 
 --verbose           Prints detailed information about linked packages  
 `;
 

package/bin/commands/link.js

@@ -11,10 +11,10 @@ var _utils = require("../utils/utils");
 /* eslint-disable valid-jsdoc */
 
 const repositoryDirNameRegex = new RegExp(_path.default.join('1', '2')[1] + 'public$');
-const excludedPackages = ['@datagrok/diff-grok'];
+const excludedPackages = ['@datagrok/diff-grok', ''];
 const curDir = process.cwd();
-let devMode = false;
 let repositoryDir = curDir;
+let currentPackage;
 let localPackageDependencies;
 let packagesToLink;
 while (_path.default.dirname(repositoryDir) !== repositoryDir) {
@@ -22,6 +22,9 @@ while (_path.default.dirname(repositoryDir) !== repositoryDir) {
   repositoryDir = _path.default.dirname(repositoryDir);
 }
 let verbose = false;
+let pathMode = false;
+let devMode = false;
+let unlink = false;
 const apiDir = _path.default.join(repositoryDir, 'js-api');
 const libDir = _path.default.join(repositoryDir, 'libraries');
 const packageDir = _path.default.join(repositoryDir, 'packages');
@@ -30,22 +33,38 @@ const libName = '@datagrok-libraries/';
 const packageName = '@datagrok/';
 async function link(args) {
   verbose = args.verbose ?? false;
+  devMode = args.dev ?? false;
+  pathMode = args.path ?? false;
+  unlink = args.unlink ?? false;
   localPackageDependencies = [];
   packagesToLink = new Set();
-  if (args.dev !== undefined) devMode = args.dev;
   collectPackagesData(curDir);
-  await linkPackages();
-  console.log('Package linked');
+  currentPackage = new PackageData(curDir);
+  if (unlink) {
+    await unlinkPackages();
+    console.log('Package unlinked');
+  } else {
+    await linkPackages();
+    if (pathMode) console.log('Updated dependencies to local in package.json');else console.log('All packages/libraries linked to your package by nmp link command');
+  }
   return true;
 }
 function collectPackagesData(packagePath = curDir) {
   const packageJsonPath = _path.default.join(packagePath, 'package.json');
-  if (!_fs.default.existsSync(packageJsonPath)) return [];
+  if (!_fs.default.existsSync(packageJsonPath)) return {
+    dependencies: [],
+    version: '0.0.1',
+    name: ''
+  };
   const json = JSON.parse(_fs.default.readFileSync(packageJsonPath, 'utf-8'));
-  let result = [];
-  result = result.concat(collectPacakgeDataFromJsonObject(json.dependencies));
-  if (devMode) result = result.concat(collectPacakgeDataFromJsonObject(json.devDependencies));
-  return result;
+  let dependencies = [];
+  dependencies = dependencies.concat(collectPacakgeDataFromJsonObject(json.dependencies));
+  if (devMode) dependencies = dependencies.concat(collectPacakgeDataFromJsonObject(json.devDependencies));
+  return {
+    dependencies: dependencies,
+    version: json.version,
+    name: json.name
+  };
 }
 function collectPacakgeDataFromJsonObject(object) {
   let result = [];
@@ -62,11 +81,38 @@ function parsePackageDependencies(dependencyName, pathToLink) {
   let result = [];
   if (!packagesToLink.has(dependencyName)) {
     packagesToLink.add(dependencyName);
-    localPackageDependencies.push(new PackageData(dependencyName, pathToLink));
+    localPackageDependencies.push(new PackageData(pathToLink));
   }
   result.push(dependencyName);
   return result;
 }
+async function unlinkPackages() {
+  const packaegs = [...localPackageDependencies];
+  if (currentPackage) packaegs.push(currentPackage);
+  for (let packageData of packaegs) {
+    if (excludedPackages.includes(packageData.name)) continue;
+    if (verbose) console.log(`Package ${packageData.name} is unlinking`);
+    const packageJsonPath = _path.default.join(packageData.packagePath, 'package.json');
+    const packageJson = JSON.parse(_fs.default.readFileSync(packageJsonPath, 'utf8'));
+    packageJson.dependencies = updateDependenciesToVersion(packageData, packageJson.dependencies);
+    if (devMode) packageJson.devDependencies = updateDependenciesToVersion(packageData, packageJson.devDependencies);
+    _fs.default.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
+    await (0, _utils.runScript)(`npm unlink ${packageData.name}`, packageData.packagePath);
+  }
+}
+function updateDependenciesToVersion(packageData, dependecyNode) {
+  for (let dependency of packageData.dependencies) {
+    if (excludedPackages.includes(dependency)) continue;
+    if (dependecyNode[dependency]) {
+      const packageToLink = (localPackageDependencies.filter(e => e.name === dependency) ?? [])[0];
+      if (packageToLink) {
+        const startIndex = packageToLink.packagePath.indexOf(`public${_path.default.sep}`) + `public${_path.default.sep}`.length;
+        if (startIndex !== -1) dependecyNode[dependency] = `^${packageToLink.version}`;
+      }
+    }
+  }
+  return dependecyNode;
+}
 async function linkPackages() {
   let anyChanges = true;
   for (let element of excludedPackages) packagesToLink.delete(element);
@@ -79,24 +125,56 @@ async function linkPackages() {
     let mapElements = localPackageDependencies.filter(x => x.dependencies.every(i => !packagesToLink.has(i)) && packagesToLink.has(x.name) && !excludedPackages.includes(x.name));
     if (mapElements.length === 0) break;
     for (let element of mapElements) {
-      if (verbose) console.log(`Package ${element.name} linked`);
+      if (verbose) console.log(`Package ${element.name} is linking`);
+      if (pathMode) await linkPathMode(element);
       await (0, _utils.runScript)(`npm install`, element.packagePath);
-      await (0, _utils.runScript)(`npm link ${element.dependencies.join(' ')}`, element.packagePath);
-      await (0, _utils.runScript)(`npm link`, element.packagePath);
+      if (pathMode) await (0, _utils.runScript)(`npm run build`, element.packagePath);
+      if (!pathMode) await linkNpmMode(element);
       packagesToLink.delete(element.name);
       anyChanges = true;
     }
     if (anyChanges === false) throw new Error(`There is loop with next packages: ${JSON.stringify(Array.from(packagesToLink)).toString()}`);
   }
   let names = localPackageDependencies.map(x => x.name);
+  if (currentPackage && pathMode) await linkPathMode(currentPackage);
   await (0, _utils.runScript)(`npm install`, curDir);
-  await (0, _utils.runScript)(`npm link ${names.join(' ')}`, curDir);
+  if (pathMode === false) await (0, _utils.runScript)(`npm link ${names.join(' ')}`, curDir);
+}
+async function linkNpmMode(packageData) {
+  await (0, _utils.runScript)(`npm link ${packageData.dependencies.join(' ')}`, packageData.packagePath);
+  await (0, _utils.runScript)(`npm link`, packageData.packagePath);
+}
+async function linkPathMode(packageData) {
+  const packageJsonPath = _path.default.join(packageData.packagePath, 'package.json');
+  const packageJson = JSON.parse(_fs.default.readFileSync(packageJsonPath, 'utf8'));
+  packageJson.dependencies = packageJson.dependencies || {};
+  packageJson.devDependencies = packageJson.devDependencies || {};
+  packageJson.dependencies = updateDependenciesToLocal(packageData, packageJson.dependencies);
+  if (devMode) packageJson.devDependencies = updateDependenciesToLocal(packageData, packageJson.devDependencies);
+  _fs.default.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
+}
+function updateDependenciesToLocal(packageData, dependecyNode) {
+  const dirNames = packageData.packagePath.split(_path.default.sep);
+  const backRoute = `../`.repeat(dirNames.length - dirNames.indexOf('public') - 1);
+  for (let dependency of packageData.dependencies) {
+    if (excludedPackages.includes(dependency)) continue;
+    if (dependecyNode[dependency]) {
+      const packageToLink = (localPackageDependencies.filter(e => e.name === dependency) ?? [])[0];
+      if (packageToLink) {
+        const startIndex = packageToLink.packagePath.indexOf(`public${_path.default.sep}`) + `public${_path.default.sep}`.length;
+        if (startIndex !== -1) dependecyNode[dependency] = `${backRoute}${packageToLink.packagePath.substring(startIndex).replaceAll(_path.default.sep, '/')}`;
+      }
+    }
+  }
+  return dependecyNode;
 }
 class PackageData {
   dependencies = [];
-  constructor(name, packagePath) {
-    this.name = name;
+  constructor(packagePath) {
+    let packageJsonData = collectPackagesData(packagePath);
+    this.name = packageJsonData.name;
     this.packagePath = packagePath;
-    this.dependencies = collectPackagesData(packagePath);
+    this.dependencies = packageJsonData.dependencies;
+    this.version = packageJsonData.version;
   }
 }

package/bin/utils/func-generation.js

@@ -375,10 +375,11 @@ const reservedDecorators = exports.reservedDecorators = {
 function generateClassFunc(annotation, className, sep = '\n') {
   return annotation + `export function _${className}() {${sep}  return new ${className}();${sep}}${sep.repeat(2)}`;
 }
+const primitives = new Set(['string', 'string[]', 'number', 'number[]', 'boolean', 'boolean[]']);
 
 /** Generates a DG function. */
 function generateFunc(annotation, funcName, sep = '\n', className = '', inputs = [], isAsync = false) {
-  let funcSigNature = inputs.map(e => `${e.name}: ${e.type}`).join(', ');
+  let funcSigNature = inputs.map(e => `${e.name}: ${primitives.has(e.type ?? '') ? e.type : 'any'}`).join(', ');
   let funcArguments = inputs.map(e => e.name).join(', ');
   return annotation + `export ${isAsync ? 'async ' : ''}function ${funcName}(${funcSigNature}) {${sep}  return ${className.length > 0 ? `${className}.` : ''}${funcName}(${funcArguments});${sep}}${sep.repeat(2)}`;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "datagrok-tools",
-  "version": "4.14.0",
+  "version": "4.14.2",
   "description": "Utility to upload and publish packages to Datagrok",
   "homepage": "https://github.com/datagrok-ai/public/tree/master/tools#readme",
   "dependencies": {

package/plugins/func-gen-plugin.js

@@ -179,10 +179,11 @@ class FuncGeneratorPlugin {
           name += ': ' + generate(baseParam.argument.typeAnnotation.typeAnnotation).code;
     
         let type = '';
-        if (baseParam?.typeAnnotation?.typeAnnotation?.typeName || baseParam?.typeAnnotation?.typeAnnotation?.elementType?.typeName)
-          type = 'any';
-        else if (baseParam?.typeAnnotation?.typeAnnotation)
+        if (baseParam?.typeAnnotation?.typeAnnotation)
           type = generate(baseParam.typeAnnotation.typeAnnotation).code;
+        else 
+          type = 'any';
+        
         let params = baseParam.typeAnnotation.typeAnnotation.typeArguments?.params;
         if(type !== 'any' && params && params.length > 0)
           type += `<${params.map((e)=>e.typeName.name).join(',')}>`;