datagrok-tools 4.14.5 → 4.14.7

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Datagrok-tools changelog
 
+## 4.14.6 (2025-05-29)
+
+### Features
+
+* Decorators added ability to set hardcoded values
+* Decorators added ability to get outputs from multiple parameters 
+
+
 ## 4.14.2 (2025-05-16)
 
 ### Features

package/bin/commands/check.js

@@ -21,20 +21,21 @@ var testUtils = _interopRequireWildcard(require("../utils/test-utils"));
 function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
 function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
 const warns = ['Latest package version', 'Datagrok API version should contain'];
-const forbidenNames = ['function', 'class', 'export'];
+const forbiddenNames = ['function', 'class', 'export'];
+const namesInFiles = new Map();
 function check(args) {
   const nOptions = Object.keys(args).length - 1;
   if (args['_'].length !== 1 || nOptions > 2 || nOptions > 0 && !args.r && !args.recursive) return false;
   const curDir = process.cwd();
-  if (args.recursive) return runChecksRec(curDir);else {
+  if (args.recursive) return runChecksRec(curDir, args.soft ?? false);else {
     if (!utils.isPackageDir(curDir)) {
       color.error('File `package.json` not found. Run the command from the package directory');
       return false;
     }
-    return runChecks(curDir);
+    return runChecks(curDir, args.soft ?? false);
   }
 }
-function runChecks(packagePath) {
+function runChecks(packagePath, soft = false) {
   const files = _ignoreWalk.default.sync({
     path: packagePath,
     ignoreFiles: ['.npmignore', '.gitignore']
@@ -77,20 +78,20 @@ function runChecks(packagePath) {
   if (errors.length) {
     console.log(`Checking package ${_path.default.basename(packagePath)}...`);
     showError(errors);
-    if (json.version.startsWith('0') || errors.every(w => warns.some(ww => w.includes(ww)))) return true;
+    if (soft || json.version.startsWith('0') || errors.every(w => warns.some(ww => w.includes(ww)))) return true;
     testUtils.exitWithCode(1);
   }
   console.log(`Checking package ${_path.default.basename(packagePath)}...\t\t\t\u2713 OK`);
   return true;
 }
-function runChecksRec(dir) {
+function runChecksRec(dir, soft = false) {
   const files = _fs.default.readdirSync(dir);
   for (const file of files) {
     const filepath = _path.default.join(dir, file);
     const stats = _fs.default.statSync(filepath);
     if (stats.isDirectory()) {
-      if (utils.isPackageDir(filepath)) return runChecks(filepath);else {
-        if (file !== 'node_modules' && !file.startsWith('.')) runChecksRec(_path.default.join(dir, file));
+      if (utils.isPackageDir(filepath)) return runChecks(filepath, soft);else {
+        if (file !== 'node_modules' && !file.startsWith('.')) runChecksRec(_path.default.join(dir, file), soft);
       }
     }
   }
@@ -315,13 +316,20 @@ function checkFuncSignatures(packagePath, files) {
           warnings.push(`File ${file}, function ${f.name}:\n${vr.message}`);
         }
       }
-      let wrongInputNames = f.inputs.filter(e => forbidenNames.includes(e?.name ?? ''));
+      let wrongInputNames = f.inputs.filter(e => forbiddenNames.includes(e?.name ?? ''));
+      if (f.name) {
+        console.log(f);
+        if (namesInFiles.has(f.name)) namesInFiles.get(f.name)?.push(file);else namesInFiles.set(f.name, [file]);
+      }
       if (wrongInputNames.length > 0) warnings.push(`File ${file}, function ${f.name}: Wrong input names: (${wrongInputNames.map(e => e.name).join(', ')})`);
       if (f.isInvalidateOnWithoutCache) warnings.push(`File ${file}, function ${f.name}: Can't use invalidateOn without cache, please follow this example: 'meta.cache.invalidateOn'`);
-      if (f.cache) if (!utils.cahceValues.includes(f.cache)) warnings.push(`File ${file}, function ${f.name}: unsupposed variable for cache : ${f.cache}`);
+      if (f.cache) if (!utils.cacheValues.includes(f.cache)) warnings.push(`File ${file}, function ${f.name}: unsupposed variable for cache : ${f.cache}`);
       if (f.invalidateOn) if (!utils.isValidCron(f.invalidateOn)) warnings.push(`File ${file}, function ${f.name}: unsupposed variable for invalidateOn : ${f.invalidateOn}`);
     }
   }
+  for (const [name, files] of namesInFiles) {
+    if (files.length > 1) warnings.push(`Duplicate names ('${name}'): \n  ${files.join('\n  ')}`);
+  }
   return warnings;
 }
 const sharedLibExternals = {
@@ -519,7 +527,8 @@ function getFuncMetadata(script, fileExtention) {
     if (match) {
       if (!isHeader) isHeader = true;
       const param = match[1];
-      if (param === 'name') data.name = line.match(utils.nameAnnRegex)?.[2];else if (param === 'description') data.description = match[2];else if (param === 'input') {
+      console.log(param);
+      if (param === 'name') data.name = line.match(utils.nameAnnRegex)?.[2]?.toLocaleLowerCase();else if (param === 'description') data.description = match[2];else if (param === 'input') {
         data.inputs.push({
           type: match[2],
           name: match[3]
@@ -539,8 +548,8 @@ function getFuncMetadata(script, fileExtention) {
     }
     if (isHeader) {
       const nm = line.match(utils.nameRegex);
-      if (nm && !match) {
-        data.name = data.name || nm[1];
+      if (nm) data.name = nm[1]?.toLocaleLowerCase();
+      if (data.name && !match) {
         funcData.push(data);
         data = {
           name: '',

package/bin/utils/utils.js

@@ -4,7 +4,7 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.cahceValues = exports.absUrlRegex = exports.TemplateBuilder = void 0;
+exports.cacheValues = exports.absUrlRegex = exports.TemplateBuilder = void 0;
 exports.camelCaseToKebab = camelCaseToKebab;
 exports.checkScriptLocation = checkScriptLocation;
 exports.commentMap = void 0;
@@ -165,7 +165,7 @@ function getParam(name, script, comment = '#') {
   return match ? match[1]?.trim() : null;
 }
 ;
-const cahceValues = exports.cahceValues = ['all', 'server', 'client', 'true'];
+const cacheValues = exports.cacheValues = ['all', 'server', 'client', 'true'];
 function isValidCron(cronExpression) {
   const cronRegex = /^(\*|([0-9]|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9])|\*\/([0-9]|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9])) (\*|([0-9]|1[0-9]|2[0-3])|\*\/([0-9]|1[0-9]|2[0-3])) (\*|([1-9]|1[0-9]|2[0-9]|3[0-1])|\*\/([1-9]|1[0-9]|2[0-9]|3[0-1])) (\*|([1-9]|1[0-2])|\*\/([1-9]|1[0-2])) (\*|([0-6])|\*\/([0-6]))$/;
   return cronRegex.test(cronExpression);
@@ -183,15 +183,15 @@ const dgToTsTypeMap = exports.dgToTsTypeMap = {
   view: 'DG.View'
 };
 const propertyTypes = exports.propertyTypes = ['bool', 'int', 'double', 'string', 'datetime', 'object', 'column', 'dataframe', 'bitset', 'cell', 'string_list', 'map'];
-const headerTags = exports.headerTags = ['name', 'description', 'help-url', 'input', 'output', 'tags', 'sample', 'language', 'returns', 'test', 'sidebar', 'condition', 'top-menu', 'environment', 'require', 'editor-for', 'schedule', 'reference', 'editor', 'meta'];
+const headerTags = exports.headerTags = ['name', 'description', 'help-url', 'input', 'output', 'tags', 'sample', 'language', 'returns', 'test', 'sidebar', 'condition', 'top-menu', 'environment', 'require', 'editor-for', 'schedule', 'reference', 'editor', 'meta', 'connection', 'friendlyName'];
 const fileParamRegex = exports.fileParamRegex = {
   py: new RegExp(`^\#\\s*((?:${headerTags.join('|')})[^:]*): *([^\\s\\[\\{]+) ?([^\\s\\[\\{]+)?[^\\n]*$`),
   ts: new RegExp(`^\/\/\\s*((?:${headerTags.join('|')})[^:]*): *([^\\s\\[\\{]+) ?([^\\s\\[\\{]+)?[^\\n]*$`),
   js: new RegExp(`^\/\/\\s*((?:${headerTags.join('|')})[^:]*): *([^\\s\\[\\{]+) ?([^\\s\\[\\{]+)?[^\\n]*$`),
   sql: new RegExp(`^--\\s*((?:${headerTags.join('|')})[^:]*): *([^\\s\\[\\{]+) ?([^\\s\\[\\{]+)?[^\\n]*$`)
 };
-const nameAnnRegex = exports.nameAnnRegex = /\/\/\s*(name[^:]*): ([^\n\r\[\{]+)/;
-const nameRegex = exports.nameRegex = /(?:|(?:static)(?:export )(?:async )function )\s+([a-zA-Z_][a-zA-Z0-9_$]*)\s*\((.*?).*/;
+const nameAnnRegex = exports.nameAnnRegex = /\s*(name[^:]*): ([^\n\r\[\{]+)/;
+const nameRegex = exports.nameRegex = /(?:|(?:static)(?:export )(?:async ))\s+function\s+([a-zA-Z_][a-zA-Z0-9_$]*)\s*\((.*?).*/;
 const absUrlRegex = exports.absUrlRegex = new RegExp('^(?:[a-z+]+:)?//', 'i');
 function getScriptOutputType(script, comment = '#') {
   const regex = new RegExp(`${comment}\\s*output:\\s?([a-z_]+)\\s*`);
@@ -245,7 +245,7 @@ async function runScript(script, path, verbose = false) {
     }
   } catch (error) {
     console.error(`Execution failed: ${error.message}`);
-    throw new Error(`Cant run script ${script}`);
+    throw new Error(`Error executing '${script}'. Error message: ${error.message}`);
   }
 }
 function setHost(host, configFile) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "datagrok-tools",
-  "version": "4.14.5",
+  "version": "4.14.7",
   "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

@@ -125,12 +125,7 @@ class FuncGeneratorPlugin {
     ]);
     const functionParams =
       node?.type === "MethodDefinition" ? this._readMethodParamas(node) : [];
-    const annotationByReturnType = node?.type === "MethodDefinition" ? this._readReturnType(node) : "";
-
-    const annotationByReturnTypeObj = {
-      name: "result",
-      type: annotationByReturnType,
-    };
+    const annotationByReturnObj = node?.type === "MethodDefinition" ? this._readOutputsFromReturnType(node) : undefined;
     const isMethodAsync = this._isMethodAsync(node);
     let importString = generateImport(
       node?.type === "MethodDefinition" ? className : identifierName,
@@ -142,8 +137,8 @@ class FuncGeneratorPlugin {
     }${identifierName}`;
     const funcAnnotaionOptions = {
       ...reservedDecorators[name]["metadata"],
-      ...(annotationByReturnType
-        ? { outputs: [annotationByReturnTypeObj ?? {}] }
+      ...(annotationByReturnObj
+        ? { outputs: annotationByReturnObj ?? [] }
         : {}),
       ...Object.fromEntries(decoratorOptions),
       ...{ inputs: functionParams },
@@ -345,21 +340,14 @@ class FuncGeneratorPlugin {
     }
   }
 
-  _readReturnType(node) {
+  _readReturnType(annotation) {
     let resultType = "dynamic";
-    let isArray = false;
-    let annotation = node.value?.returnType?.typeAnnotation;
+    let isArray = false; 
     if (
       annotation &&
       annotation.type !== "TSUnionType" &&
       annotation.type !== "TSIntersectionType"
     ) {
-      // if (annotation?.typeName?.name === "Promise") {
-      //   const argumnets = annotation.typeArguments?.params;
-      //   if (argumnets && argumnets.length === 1) {
-      //     annotation = argumnets[0];
-      //   } else annotation = {};
-      // }
       
       if (annotation.typeName || annotation.type === "TSTypeReference")
         resultType =
@@ -377,12 +365,49 @@ class FuncGeneratorPlugin {
           annotation?.elementType?.typeName?.right?.name;
       } 
     }
-
     resultType = typesToAnnotation[resultType];
     if (isArray && resultType) resultType = `list`;
     return resultType ?? 'dynamic';
   }
 
+  _readOutputsFromReturnType(node) {
+    let results = [];
+    let annotation = node.value?.returnType?.typeAnnotation;
+
+    if (node?.type === 'ClassDeclaration')
+      return [];
+    
+    if (annotation?.typeName?.name === "Promise") {
+      const argumnets = annotation.typeArguments?.params;
+      if (argumnets && argumnets.length === 1) {
+        annotation = argumnets[0];
+      } else annotation = {};
+    }
+
+    if (annotation?.type === "TSTypeLiteral"){
+      results = this._readOutputsFromReturnTypeObject(annotation);
+    }
+    else{
+      let resultType = this._readReturnType(annotation);
+      results.push({name: 'result', type: resultType});
+      if (resultType === 'void')
+        results = [];
+    }
+    return results;
+  }
+
+  _readOutputsFromReturnTypeObject(node) {
+    let i = 0;
+    let results = [];
+    for (let member of node.members) {
+      results.push({
+        name: member?.key?.name ?? `result${i}`,
+        type: this._readReturnType(member.typeAnnotation.typeAnnotation),
+      });
+      i++;
+    }
+    return results;
+  }
 
   _getTypeNameFromNode(typeNode) {
     if (typeNode.type === "TSTypeReference") {