datagrok-tools 4.14.2 → 4.14.4

package/bin/commands/api.js

@@ -12,18 +12,24 @@ var utils = _interopRequireWildcard(require("../utils/utils"));
 var color = _interopRequireWildcard(require("../utils/color-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 sep = '\n';
+const packageFuncDirs = ['package.ts', 'package.g.ts'];
+const apiFile = 'package-api.ts';
+const curDir = process.cwd();
+const srcDir = _path.default.join(curDir, 'src');
+const funcFilePath = _path.default.join(_fs.default.existsSync(srcDir) ? srcDir : curDir, apiFile);
+const packagePath = _path.default.join(curDir, 'package.json');
+const names = new Set();
+const _package = JSON.parse(_fs.default.readFileSync(packagePath, {
+  encoding: 'utf-8'
+}));
 function generateQueryWrappers() {
-  const curDir = process.cwd();
   const queriesDir = _path.default.join(curDir, 'queries');
   if (!_fs.default.existsSync(queriesDir)) {
     color.warn(`Directory ${queriesDir} not found`);
     console.log('Skipping API generation for queries...');
     return;
   }
-  const packagePath = _path.default.join(curDir, 'package.json');
-  const _package = JSON.parse(_fs.default.readFileSync(packagePath, {
-    encoding: 'utf-8'
-  }));
   const files = _ignoreWalk.default.sync({
     path: './queries',
     ignoreFiles: ['.npmignore', '.gitignore']
@@ -34,44 +40,30 @@ function generateQueryWrappers() {
     const filepath = _path.default.join(queriesDir, file);
     const script = _fs.default.readFileSync(filepath, 'utf8');
     if (!script) continue;
-    const queries = script.split('--end').map(q => q.trim()).filter(q => q.length > 0);
+    const queries = script.split(/--\s*end/).map(q => q.trim()).filter(q => q.length > 0);
     for (const q of queries) {
       const name = utils.getScriptName(q, utils.commentMap[utils.queryExtension]);
       if (!name) continue;
+      checkNameColision(name);
       const tb = new utils.TemplateBuilder(utils.queryWrapperTemplate).replace('FUNC_NAME', name).replace('FUNC_NAME_LOWERCASE', name).replace('PACKAGE_NAMESPACE', _package.name);
+      const description = utils.getScriptDescription(q, utils.commentMap[utils.queryExtension]);
       const inputs = utils.getScriptInputs(q, utils.commentMap[utils.queryExtension]);
       const outputType = utils.getScriptOutputType(q, utils.commentMap[utils.queryExtension]);
-      tb.replace('PARAMS_OBJECT', inputs).replace('TYPED_PARAMS', inputs)
-      // The query output, if omitted, is a dataframe
-      .replace('OUTPUT_TYPE', outputType === 'void' ? utils.dgToTsTypeMap['dataframe'] : outputType);
-      wrappers.push(tb.build());
+      tb.replace('PARAMS_OBJECT', inputs).replace('TYPED_PARAMS', inputs).replace('FUNC_DESCRIPTION', description).replace('OUTPUT_TYPE', outputType === 'void' ? utils.dgToTsTypeMap['dataframe'] : outputType);
+      wrappers.push(tb.build(1));
     }
   }
-  const srcDir = _path.default.join(curDir, 'src');
-  const queryFileName = 'queries-api.ts';
-  const queryFilePath = _path.default.join(_fs.default.existsSync(srcDir) ? srcDir : curDir, queryFileName);
-  if (_fs.default.existsSync(queryFilePath)) {
-    color.warn(`The file ${queryFilePath} already exists`);
-    console.log('Rewriting its contents...');
-  }
-  const sep = '\n';
-  _fs.default.writeFileSync(queryFilePath, utils.dgImports + sep + wrappers.join(sep.repeat(2)) + sep, 'utf8');
-  color.success(`Successfully generated file ${queryFileName}${sep}`);
+  saveWrappersToFile('queries', wrappers);
 }
 function generateScriptWrappers() {
-  const curDir = process.cwd();
   const scriptsDir = _path.default.join(curDir, 'scripts');
   if (!_fs.default.existsSync(scriptsDir)) {
     color.warn(`Directory ${scriptsDir} not found`);
     console.log('Skipping API generation for scripts...');
     return;
   }
-  const packagePath = _path.default.join(curDir, 'package.json');
-  const _package = JSON.parse(_fs.default.readFileSync(packagePath, {
-    encoding: 'utf-8'
-  }));
   const files = _ignoreWalk.default.sync({
-    path: './scripts',
+    path: scriptsDir,
     ignoreFiles: ['.npmignore', '.gitignore']
   });
   const wrappers = [];
@@ -83,23 +75,62 @@ function generateScriptWrappers() {
     if (!script) continue;
     const name = utils.getScriptName(script, utils.commentMap[extension]);
     if (!name) continue;
+    const description = utils.getScriptDescription(script);
+    checkNameColision(name);
     const tb = new utils.TemplateBuilder(utils.scriptWrapperTemplate).replace('FUNC_NAME', name).replace('FUNC_NAME_LOWERCASE', name).replace('PACKAGE_NAMESPACE', _package.name);
     const inputs = utils.getScriptInputs(script);
     const outputType = utils.getScriptOutputType(script);
-    tb.replace('PARAMS_OBJECT', inputs).replace('TYPED_PARAMS', inputs).replace('OUTPUT_TYPE', outputType);
+    tb.replace('PARAMS_OBJECT', inputs).replace('TYPED_PARAMS', inputs).replace('FUNC_DESCRIPTION', description).replace('OUTPUT_TYPE', outputType);
     wrappers.push(tb.build(1));
   }
-  const srcDir = _path.default.join(curDir, 'src');
-  const funcFileName = 'scripts-api.ts';
-  const funcFilePath = _path.default.join(_fs.default.existsSync(srcDir) ? srcDir : curDir, funcFileName);
+  saveWrappersToFile('scripts', wrappers);
+}
+function generateFunctionWrappers() {
+  let filesToParse = packageFuncDirs.map(e => _path.default.join(curDir, 'src', e)).filter(e => _fs.default.existsSync(e));
+  const annotaionRegex = /(?:\/\/[^\n]*\n)+export[^{]*/g;
+  const nameRegex = /\s*export(?:\sasync)?\s*function\s*([^\s(]*)/;
+  const wrappers = [];
+  for (const file of filesToParse) {
+    const fileData = _fs.default.readFileSync(file, 'utf8');
+    const annotations = fileData.matchAll(annotaionRegex);
+    if (annotations === null) return;
+    for (let annotation of annotations) {
+      const name = (annotation[0].match(nameRegex) ?? [undefined, undefined])[1];
+      const description = utils.getScriptDescription(annotation[0], utils.commentMap[utils.jsExtention]);
+      if (!name) continue;
+      const annotationInputs = utils.getScriptInputs(annotation[0], utils.commentMap[utils.jsExtention]);
+      const annotationOutputDir = utils.getScriptOutputType(annotation[0], utils.commentMap[utils.jsExtention]);
+      let outputType = '';
+      for (let outputAnnotation of annotationOutputDir) {
+        if (outputType != '') {
+          outputType = 'any';
+          break;
+        }
+        outputType = utils.dgToTsTypeMap[outputAnnotation[1]] ?? 'any';
+      }
+      checkNameColision(name);
+      const tb = new utils.TemplateBuilder(utils.scriptWrapperTemplate).replace('FUNC_NAME', name).replace('FUNC_NAME_LOWERCASE', name).replace('PACKAGE_NAMESPACE', _package.name).replace('PARAMS_OBJECT', annotationInputs).replace('FUNC_DESCRIPTION', description).replace('TYPED_PARAMS', annotationInputs).replace('OUTPUT_TYPE', outputType);
+      wrappers.push(tb.build(1));
+    }
+  }
+  saveWrappersToFile('funcs', wrappers);
+}
+function saveWrappersToFile(namespaceName, wrappers) {
+  if (!_fs.default.existsSync(funcFilePath)) createApiFile();
+  const scriptApi = new utils.TemplateBuilder(utils.namespaceTemplate).replace('PACKAGE_NAMESPACE', namespaceName).replace('NAME', wrappers.join(sep.repeat(2)));
+  _fs.default.appendFileSync(funcFilePath, sep + scriptApi.build() + sep);
+  color.success(`Successfully generated file ${apiFile}${sep}`);
+}
+function createApiFile() {
   if (_fs.default.existsSync(funcFilePath)) {
     color.warn(`The file ${funcFilePath} already exists`);
     console.log('Rewriting its contents...');
   }
-  const sep = '\n';
-  const scriptApi = new utils.TemplateBuilder(utils.namespaceTemplate).replace('PACKAGE_NAMESPACE', _package.name).replace('NAME', wrappers.join(sep.repeat(2)));
-  _fs.default.writeFileSync(funcFilePath, utils.dgImports + sep + scriptApi.build() + sep, 'utf8');
-  color.success(`Successfully generated file ${funcFileName}${sep}`);
+  _fs.default.writeFileSync(funcFilePath, utils.dgImports + sep, 'utf8');
+}
+function checkNameColision(name) {
+  if (names.has(name)) console.log('There is collision in name ' + name);
+  names.add(name);
 }
 function api(args) {
   const nOptions = Object.keys(args).length - 1;
@@ -108,7 +139,9 @@ function api(args) {
     color.error('File `package.json` not found. Run the command from the package directory');
     return false;
   }
+  createApiFile();
   generateScriptWrappers();
   generateQueryWrappers();
+  generateFunctionWrappers();
   return true;
 }

package/bin/commands/check.js

@@ -21,6 +21,7 @@ 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'];
 function check(args) {
   const nOptions = Object.keys(args).length - 1;
   if (args['_'].length !== 1 || nOptions > 2 || nOptions > 0 && !args.r && !args.recursive) return false;
@@ -314,6 +315,8 @@ function checkFuncSignatures(packagePath, files) {
           warnings.push(`File ${file}, function ${f.name}:\n${vr.message}`);
         }
       }
+      let wrongInputNames = f.inputs.filter(e => forbidenNames.includes(e?.name ?? ''));
+      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.invalidateOn) if (!utils.isValidCron(f.invalidateOn)) warnings.push(`File ${file}, function ${f.name}: unsupposed variable for invalidateOn : ${f.invalidateOn}`);
@@ -357,8 +360,11 @@ function checkPackageFile(packagePath, json, options) {
   if (api) {
     if (api === '../../js-api') {} else if (api === 'latest') warnings.push('File "package.json": you should specify Datagrok API version constraint (for example ^1.16.0, >=1.16.0).');else if (options?.isReleaseCandidateVersion === false && !/^(\^|>|<|~).+/.test(api)) warnings.push('File "package.json": Datagrok API version should starts with > | >= | ~ | ^ | < | <=');
   }
-  const dt = json.devDependencies?.['datagrok-tools'] ?? json.dependencies?.['datagrok-tools'];
-  if (dt && dt !== 'latest') warnings.push('File "package.json": "datagrok-tools" dependency must be "latest" version.');
+
+  // const dt = json.devDependencies?.['datagrok-tools'] ?? json.dependencies?.['datagrok-tools'];
+  // if (dt && dt !== 'latest')
+  //   warnings.push('File "package.json": "datagrok-tools" dependency must be "latest" version.');
+
   if (Array.isArray(json.sources) && json.sources.length > 0) {
     for (const source of json.sources) {
       if (typeof source !== 'string') warnings.push(`File "package.json": Only file paths and URLs are allowed in sources. Modify the source ${source}`);
@@ -394,8 +400,6 @@ function checkPackageFile(packagePath, json, options) {
     }
     if (!hasRCDependency) {
       for (let dependency of Object.keys(json.dependencies ?? {})) {
-        console.log(dependency);
-        console.log((json.dependencies ?? {})[dependency]);
         if (/\d+.\d+.\d+-rc(.[A-Za-z0-9]*.[A-Za-z0-9]*)?/.test((json.devDependencies ?? {})[dependency])) {
           hasRCDependency = true;
           break;

package/bin/commands/help.js

@@ -191,12 +191,12 @@ https://datagrok.ai/help/develop/how-to/test-packages#local-testing
 const HELP_LINK = `
 Usage: grok link
 
-Link \`datagrok-api\` and libraries for local development
+Link \`datagrok-api\`, all necessary libraries and packages for local development by \`npm link\` command 
 
 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 
+--unlink            Unlinks packages and sets last versions instead of local path in package.json dependencies 
 --verbose           Prints detailed information about linked packages  
 `;
 

package/bin/utils/func-generation.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.FUNC_TYPES = void 0;
+exports.dgAnnotationTypes = exports.FUNC_TYPES = void 0;
 exports.generateClassFunc = generateClassFunc;
 exports.generateExport = generateExport;
 exports.generateFunc = generateFunc;
@@ -22,6 +22,53 @@ let pseudoParams = exports.pseudoParams = /*#__PURE__*/function (pseudoParams) {
 }({});
 const nonMetaData = ['sidebar', 'editor'];
 const decoratorOptionToAnnotation = new Map([['initialValue', 'default']]);
+const dgAnnotationTypes = exports.dgAnnotationTypes = {
+  INT: "int",
+  BIG_INT: "bigint",
+  FLOAT: "double",
+  NUM: "num",
+  QNUM: "qnum",
+  BOOL: "bool",
+  STRING: "string",
+  STRING_LIST: "string_list",
+  DATE_TIME: "datetime",
+  OBJECT: "object",
+  BYTE_ARRAY: "byte_array",
+  DATA_FRAME: "dataframe",
+  DATA_FRAME_LIST: "dataframe_list",
+  CELL: "cell",
+  COLUMN: "column",
+  COLUMN_LIST: "column_list",
+  GRAPHICS: "graphics",
+  FILE: "file",
+  BLOB: "blob",
+  ROW_FILTER: "tablerowfiltercall",
+  COLUMN_FILTER: "colfiltercall",
+  BIT_SET: "bitset",
+  MAP: "map",
+  DYNAMIC: "dynamic",
+  VIEWER: "viewer",
+  LIST: "list",
+  SEM_VALUE: "semantic_value",
+  FUNC: "func",
+  FUNC_CALL: "funccall",
+  PROPERTY: "property",
+  CATEGORICAL: "categorical",
+  NUMERICAL: "numerical",
+  GRID_CELL_RENDER_ARGS: "GridCellRenderArgs",
+  ELEMENT: "element",
+  VIEW: "view",
+  TABLE_VIEW: "TableView",
+  USER: "User",
+  MENU: "Menu",
+  PROJECT: "Project",
+  SEMANTIC_VALUE: "semantic_value",
+  EVENT_DATA: "event_data",
+  PROGRESS_INDICATOR: "progressindicator",
+  CREDENTIALS: "Credentials",
+  SCRIPT_ENVIRONMENT: "ScriptEnvironment",
+  NOTEBOOK: "Notebook"
+};
 let FUNC_TYPES = exports.FUNC_TYPES = /*#__PURE__*/function (FUNC_TYPES) {
   FUNC_TYPES["APP"] = "app";
   FUNC_TYPES["CELL_RENDERER"] = "cellRenderer";
@@ -379,7 +426,7 @@ const primitives = new Set(['string', 'string[]', 'number', 'number[]', 'boolean
 
 /** Generates a DG function. */
 function generateFunc(annotation, funcName, sep = '\n', className = '', inputs = [], isAsync = false) {
-  let funcSigNature = inputs.map(e => `${e.name}: ${primitives.has(e.type ?? '') ? e.type : 'any'}`).join(', ');
+  let funcSigNature = inputs.map(e => `${e.name}: ${primitives.has(e.type ?? '') ? e.type : typesToAnnotation[e.type?.replace('[]', '') ?? ''] ? 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/bin/utils/utils.js

@@ -9,9 +9,11 @@ exports.camelCaseToKebab = camelCaseToKebab;
 exports.checkScriptLocation = checkScriptLocation;
 exports.commentMap = void 0;
 exports.delay = delay;
+exports.descriptionToComment = descriptionToComment;
 exports.fileParamRegex = exports.dgToTsTypeMap = exports.dgImports = void 0;
 exports.friendlyNameToName = friendlyNameToName;
 exports.getParam = getParam;
+exports.getScriptDescription = getScriptDescription;
 exports.getScriptInputs = getScriptInputs;
 exports.getScriptName = getScriptName;
 exports.getScriptOutputType = getScriptOutputType;
@@ -19,6 +21,7 @@ exports.headerTags = void 0;
 exports.isEmpty = isEmpty;
 exports.isPackageDir = isPackageDir;
 exports.isValidCron = isValidCron;
+exports.jsExtention = void 0;
 exports.kebabToCamelCase = kebabToCamelCase;
 exports.mapURL = mapURL;
 exports.queryWrapperTemplate = exports.queryExtension = exports.propertyTypes = exports.namespaceTemplate = exports.nameRegex = exports.nameAnnRegex = void 0;
@@ -49,6 +52,10 @@ function kebabToCamelCase(s, firstUpper = true) {
   s = s.replace(/-./g, x => x.toUpperCase()[1]);
   return (firstUpper ? s[0].toUpperCase() : s[0].toLowerCase()) + s.slice(1);
 }
+function descriptionToComment(s) {
+  if (s.length === 0) return '';
+  return '//' + s + '\n';
+}
 function spaceToCamelCase(s, firstUpper = true) {
   s = s.replace(/\s+./g, x => x[x.length - 1].toUpperCase());
   return (firstUpper ? s[0].toUpperCase() : s[0].toLowerCase()) + s.slice(1);
@@ -97,6 +104,7 @@ const replacers = exports.replacers = {
   NAME_PREFIX: (s, name) => s.replace(/#{NAME_PREFIX}/g, name.slice(0, 3)),
   PACKAGE_DETECTORS_NAME: (s, name) => s.replace(/#{PACKAGE_DETECTORS_NAME}/g, kebabToCamelCase(name)),
   PACKAGE_NAMESPACE: (s, name) => s.replace(/#{PACKAGE_NAMESPACE}/g, kebabToCamelCase(removeScope(name))),
+  FUNC_DESCRIPTION: (s, desc) => s.replace(/#{FUNC_DESCRIPTION}/g, descriptionToComment(desc)),
   FUNC_NAME: (s, name) => s.replace(/#{FUNC_NAME}/g, friendlyNameToName(name)),
   FUNC_NAME_LOWERCASE: (s, name) => s.replace(/#{FUNC_NAME_LOWERCASE}/g, friendlyNameToName(name, false)),
   PARAMS_OBJECT: (s, params) => s.replace(/#{PARAMS_OBJECT}/g, params.length ? `{ ${params.map(p => p.name).join(', ')} }` : `{}`),
@@ -138,6 +146,7 @@ const commentMap = exports.commentMap = {
   '.sql': '--'
 };
 const queryExtension = exports.queryExtension = '.sql';
+const jsExtention = exports.jsExtention = '.js';
 const scriptExtensions = exports.scriptExtensions = ['.jl', '.m', '.py', '.R'];
 function checkScriptLocation(filepath) {
   if (!(filepath.startsWith('scripts/') || filepath.startsWith('projects/') || filepath.startsWith('dockerfiles/')) && scriptExtensions.some(ext => filepath.endsWith(ext))) return false;
@@ -170,7 +179,8 @@ const dgToTsTypeMap = exports.dgToTsTypeMap = {
   dataframe: 'DG.DataFrame',
   column: 'DG.Column',
   column_list: 'string[]',
-  file: 'DG.FileInfo'
+  file: 'DG.FileInfo',
+  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'];
@@ -204,11 +214,18 @@ function getScriptInputs(script, comment = '#') {
   return inputs;
 }
 ;
+function getScriptDescription(script, comment = '#') {
+  const regex = new RegExp(`${comment}\\s*description:\\s([^\n]*)`);
+  const rexegRes = script.match(regex) || [];
+  const desc = rexegRes[1] || '';
+  return desc;
+}
+;
 const dgImports = exports.dgImports = `import * as grok from 'datagrok-api/grok';\nimport * as DG from 'datagrok-api/dg';\n\n`;
-const scriptWrapperTemplate = exports.scriptWrapperTemplate = `export async function #{FUNC_NAME_LOWERCASE}(#{TYPED_PARAMS}): Promise<#{OUTPUT_TYPE}> {
+const scriptWrapperTemplate = exports.scriptWrapperTemplate = `#{FUNC_DESCRIPTION}export async function #{FUNC_NAME_LOWERCASE}(#{TYPED_PARAMS}): Promise<#{OUTPUT_TYPE}> {
   return await grok.functions.call('#{PACKAGE_NAMESPACE}:#{FUNC_NAME}', #{PARAMS_OBJECT});
 }`;
-const queryWrapperTemplate = exports.queryWrapperTemplate = `export async function #{FUNC_NAME_LOWERCASE}(#{TYPED_PARAMS}): Promise<#{OUTPUT_TYPE}> {
+const queryWrapperTemplate = exports.queryWrapperTemplate = `#{FUNC_DESCRIPTION}export async function #{FUNC_NAME_LOWERCASE}(#{TYPED_PARAMS}): Promise<#{OUTPUT_TYPE}> {
   return await grok.data.query('#{PACKAGE_NAMESPACE}:#{FUNC_NAME}', #{PARAMS_OBJECT});
 }`;
 const namespaceTemplate = exports.namespaceTemplate = `export namespace #{PACKAGE_NAMESPACE} {\n#{NAME}\n}`;

package/package.json

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

@@ -2,17 +2,18 @@ const fs = require("fs");
 const path = require("path");
 
 const tsParser = require("@typescript-eslint/typescript-estree");
-const generate = require('@babel/generator').default;
+const generate = require("@babel/generator").default;
 
 const {
   reservedDecorators,
   getFuncAnnotation,
   generateImport,
   generateExport,
-  typesToAnnotation
+  typesToAnnotation,
+  dgAnnotationTypes,
 } = require("../bin/utils/func-generation");
 
-const baseImport = '\n';
+const baseImport = "import * as DG from 'datagrok-api/dg';\n";
 
 class FuncGeneratorPlugin {
   constructor(options = { outputPath: "./src/package.g.ts" }) {
@@ -33,9 +34,8 @@ class FuncGeneratorPlugin {
 
       for (const file of tsFiles) {
         const content = fs.readFileSync(file, "utf-8");
-        if(!content.includes('@grok.decorators.'))
-          continue;
-        
+        if (!content.includes("@grok.decorators.")) continue;
+
         if (!content) continue;
         const ast = tsParser.parse(content, {
           sourceType: "module",
@@ -51,73 +51,134 @@ class FuncGeneratorPlugin {
           const decorators = node.decorators;
           if (!decorators || decorators.length === 0) return;
 
-          if (node?.type === "ClassDeclaration") 
-            this._addNodeData(node, file, srcDirPath, functions, imports, genImports, genExports);
+          if (node?.type === "ClassDeclaration")
+            this._addNodeData(
+              node,
+              file,
+              srcDirPath,
+              functions,
+              imports,
+              genImports,
+              genExports
+            );
 
           if (node?.type === "MethodDefinition")
-            this._addNodeData(node, file, srcDirPath, functions, imports, genImports, genExports, parentClass);
+            this._addNodeData(
+              node,
+              file,
+              srcDirPath,
+              functions,
+              imports,
+              genImports,
+              genExports,
+              parentClass
+            );
         });
         this._insertImports([...imports]);
         fs.appendFileSync(this.options.outputPath, functions.join(""), "utf-8");
       }
       this._checkPackageFileForDecoratorsExport(packageFilePath);
-      // Uncommment to add obvious import/export 
+      // Uncommment to add obvious import/export
       // this._writeToPackageFile(packageFilePath, genImports, genExports);
-
     });
   }
 
-  _addNodeData(node, file, srcDirPath, functions, imports, genImports, genExports, parent = undefined) {
-    if (!node.decorators || !node.decorators.length || node.decorators?.length === 0)
+  _addNodeData(
+    node,
+    file,
+    srcDirPath,
+    functions,
+    imports,
+    genImports,
+    genExports,
+    parent = undefined
+  ) {
+    if (
+      !node.decorators ||
+      !node.decorators.length ||
+      node.decorators?.length === 0
+    )
       return;
 
     function modifyImportPath(dirPath, filePath) {
       const relativePath = path.relative(dirPath, filePath);
-      return `./${relativePath.slice(0, relativePath.length - 3).replace(/\\/g, '/')}`;
+      return `./${relativePath
+        .slice(0, relativePath.length - 3)
+        .replace(/\\/g, "/")}`;
     }
 
-    const decorator =  node.decorators[0];
-    const exp  = decorator.expression;
+    const decorator = node.decorators[0];
+    const exp = decorator.expression;
     const name = exp.callee?.property?.name || exp.callee?.name;
     const identifierName = node.id?.name || node.key?.name;
     const className = parent?.id?.name || parent?.key?.name;
 
     if (!name) return;
 
-    const decoratorOptions = this._readDecoratorOptions(exp.arguments[0].properties);
-    decoratorOptions.set('tags', [...(reservedDecorators[name]['metadata']['tags'] ?? [] ), ...(decoratorOptions.get('tags') ?? [])])
-    const functionParams = node?.type === 'MethodDefinition' ? this._readMethodParamas(node) : [];
-    const annotationByReturnType = node?.type === 'MethodDefinition' ? this._readFunctionReturnTypeInfo(node) : '';
-    const annotationByReturnTypeObj = { name: 'result', type: annotationByReturnType };
+    const decoratorOptions = this._readDecoratorOptions(
+      exp.arguments[0].properties
+    );
+
+    decoratorOptions.set("tags", [
+      ...(reservedDecorators[name]["metadata"]["tags"] ?? []),
+      ...(decoratorOptions.get("tags") ?? []),
+    ]);
+    const functionParams =
+      node?.type === "MethodDefinition" ? this._readMethodParamas(node) : [];
+    const annotationByReturnType = node?.type === "MethodDefinition" ? this._readReturnType(node) : "";
+
+    const annotationByReturnTypeObj = {
+      name: "result",
+      type: annotationByReturnType,
+    };
     const isMethodAsync = this._isMethodAsync(node);
-    let importString = generateImport(node?.type === 'MethodDefinition' ? className : identifierName, modifyImportPath(path.dirname(this.options.outputPath), file));
+    let importString = generateImport(
+      node?.type === "MethodDefinition" ? className : identifierName,
+      modifyImportPath(path.dirname(this.options.outputPath), file)
+    );
     imports.add(importString);
-    const funcName = `${node?.type === 'MethodDefinition' ? '' : '_'}${identifierName}`;
+    const funcName = `${
+      node?.type === "MethodDefinition" ? "" : "_"
+    }${identifierName}`;
     const funcAnnotaionOptions = {
-      ...reservedDecorators[name]['metadata'],
-      ...(annotationByReturnType ? {outputs: [annotationByReturnTypeObj ?? {}]} : {}),
+      ...reservedDecorators[name]["metadata"],
+      ...(annotationByReturnType
+        ? { outputs: [annotationByReturnTypeObj ?? {}] }
+        : {}),
       ...Object.fromEntries(decoratorOptions),
-      ...{inputs: functionParams},
-      ...{isAsync: isMethodAsync}
-    };    
-    if (!funcAnnotaionOptions.name)
-      funcAnnotaionOptions.name = identifierName;
-    functions.push(reservedDecorators[name]['genFunc'](getFuncAnnotation(funcAnnotaionOptions), identifierName,'\n', (className ?? ''), functionParams, funcAnnotaionOptions.isAsync ?? false));
-    genImports.push(generateImport(funcName, modifyImportPath(srcDirPath, this.options.outputPath)));
+      ...{ inputs: functionParams },
+      ...{ isAsync: isMethodAsync },
+    };
+    if (!funcAnnotaionOptions.name) funcAnnotaionOptions.name = identifierName;
+    functions.push(
+      reservedDecorators[name]["genFunc"](
+        getFuncAnnotation(funcAnnotaionOptions),
+        identifierName,
+        "\n",
+        className ?? "",
+        functionParams,
+        funcAnnotaionOptions.isAsync ?? false
+      )
+    );
+    genImports.push(
+      generateImport(
+        funcName,
+        modifyImportPath(srcDirPath, this.options.outputPath)
+      )
+    );
     genExports.push(generateExport(funcName));
   }
 
-  _isMethodAsync(node){
+  _isMethodAsync(node) {
     let result = false;
-    if (node.type === 'MethodDefinition')
-      result = node.value.async;
+    if (node.type === "MethodDefinition") result = node.value.async;
     return result;
   }
 
-  _readImports (content) {
-    const importRegex = /(import(?:[\s\w{},*]+from\s*)?['"]([^'"]+)['"];)/g;
+  _readImports(content) {
+    const importRegex = /(import(?:[\s\w{},*]+from\s*)?['']([^'']+)[''];)/g;
     const results = [];
-  
+
     let match;
     while ((match = importRegex.exec(content)) !== null) {
       results.push(`${match[1]}\n`);
@@ -125,68 +186,79 @@ class FuncGeneratorPlugin {
     return results;
   }
 
-  _readDecoratorOptions(properties){
+  _readDecoratorOptions(properties) {
     const resultMap = new Map();
 
-    for(let prop of properties)
+    for (let prop of properties)
       resultMap.set(prop.key.name, this._evalLiteral(prop.value));
-
     return resultMap;
   }
 
   _evalLiteral(node) {
     if (!node) return null;
-
     switch (node.type) {
-      case 'Literal':
+      case "Literal":
         return node.value;
 
-      case 'ArrayExpression':
-        return node.elements.map(el => this._evalLiteral(el));
+      case "ArrayExpression":
+        return node.elements.map((el) => this._evalLiteral(el));
+
+      case "MemberExpression":
+        return dgAnnotationTypes[node?.property?.name ?? ""] ?? "dynamic";
 
-      case 'ObjectExpression':
+      case "ObjectExpression":
         return Object.fromEntries(
-          node.properties.map(p => {
+          node.properties.map((p) => {
             return [p.key.name || p.key.value, this._evalLiteral(p.value)];
           })
         );
 
       default:
-        return '';
+        return "";
     }
   }
 
   _readMethodParamas(node) {
-    const params = node?.value?.params?.map(param => {
-      let baseParam = param.type === 'TSNonNullExpression' ? param.expression : param;
-      const options   = param.decorators?.length > 0?  Object.fromEntries(this._readDecoratorOptions(param.decorators[0]?.expression?.arguments[0].properties)) : undefined;
-      
-      // Commented code finds value by default of function's variable  
-      // let defaultValue = undefined; 
-      if(baseParam.type === 'AssignmentPattern')
-      {
+    const params = node?.value?.params?.map((param) => {
+      let baseParam =
+        param.type === "TSNonNullExpression" ? param.expression : param;
+      const options =
+        param.decorators?.length > 0
+          ? Object.fromEntries(
+              this._readDecoratorOptions(
+                param.decorators[0]?.expression?.arguments[0].properties
+              )
+            )
+          : undefined;
+
+      // Commented code finds value by default of function's variable
+      // let defaultValue = undefined;
+      if (baseParam.type === "AssignmentPattern") {
         // if (baseParam?.right?.type  === 'Literal')
         //   defaultValue = baseParam?.right?.raw;
         baseParam = baseParam?.left;
-      } 
+      }
 
-      if (baseParam.type === 'RestElement' || baseParam.type === 'Identifier') {
+      if (baseParam.type === "RestElement" || baseParam.type === "Identifier") {
         let name =
-          baseParam.type === 'RestElement'
+          baseParam.type === "RestElement"
             ? `...${baseParam.argument.name}`
             : baseParam.name;
         if (baseParam?.argument?.typeAnnotation)
-          name += ': ' + generate(baseParam.argument.typeAnnotation.typeAnnotation).code;
-    
-        let type = '';
+          name +=
+            ": " +
+            generate(baseParam.argument.typeAnnotation.typeAnnotation).code;
+
+        let type = "";
         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(',')}>`;
+        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(",")}>`;
+
         return { name: name, type: type, options: options };
       }
       // Commented code belove sets more strong types for ObjectPatterns and ArrayPatterns
@@ -213,7 +285,7 @@ class FuncGeneratorPlugin {
       //     });
       //     name = `[${elements.join(', ')}]`;
       //   }
-    
+
       //   let type = '';
       //   if (baseParam.typeAnnotation)
       //     type = generate(baseParam.typeAnnotation.typeAnnotation).code;
@@ -222,7 +294,7 @@ class FuncGeneratorPlugin {
 
       //   return { name: name, type: type, options: options };
       // }
-      return { name: 'value', type: 'any', options: undefined };
+      return { name: "value", type: "any", options: undefined };
     });
     return params;
   }
@@ -248,79 +320,81 @@ class FuncGeneratorPlugin {
 
   _walk(node, visitor, parent = null) {
     if (!node || typeof node !== "object") return;
-  
+
     visitor(node, parent);
-  
+
     for (const key in node) {
       const value = node[key];
       if (Array.isArray(value)) {
         value.forEach((child) => {
           if (child && typeof child.type === "string") {
-            this._walk(child, visitor, node.type === 'ClassDeclaration'? node : parent );
+            this._walk(
+              child,
+              visitor,
+              node.type === "ClassDeclaration" ? node : parent
+            );
           }
         });
       } else if (value && typeof value.type === "string") {
-        this._walk(value, visitor, node.type === 'ClassDeclaration'? node : parent );
+        this._walk(
+          value,
+          visitor,
+          node.type === "ClassDeclaration" ? node : parent
+        );
       }
     }
   }
 
-  _readFunctionReturnTypeInfo(node) { 
-    let resultType = 'any';
+  _readReturnType(node) {
+    let resultType = "dynamic";
     let isArray = false;
-    const annotation = node.value?.returnType?.typeAnnotation;
-    if (annotation) {
-      if (annotation?.typeName?.name === 'Promise')
-      {
-        const argumnets = annotation.typeArguments?.params;
-        if (argumnets && argumnets.length===1)
-        {
-          if (argumnets[0].typeName)
-            resultType = argumnets[0].typeName?.right?.name ?? argumnets[0].typeName?.name;
-          else if (argumnets[0].type !== 'TSArrayType')
-            resultType = this._getTypeNameFromNode(argumnets[0]);
-          else if (argumnets[0].elementType.type !== 'TSTypeReference'){
-            isArray = true;
-            resultType = this._getTypeNameFromNode(argumnets[0]?.elementType);
-          }
-          else{
-            isArray = true;
-            resultType = argumnets[0].elementType?.typeName?.name || argumnets[0].elementType?.typeName?.right?.name;
-          }
-        }
-      }    
-      else{      
-        if (annotation.type === 'TSTypeReference')
-          resultType = annotation.typeName?.right?.name ?? annotation.typeName?.name;
-        else if (annotation.type !== 'TSArrayType')
-          resultType = this._getTypeNameFromNode(annotation);
-        else if  (annotation.elementType.type !== 'TSTypeReference'){
-          isArray = true;
-          resultType = this._getTypeNameFromNode(annotation?.elementType);
-        }
-        else{
-          isArray = true;
-          resultType = (annotation?.elementType?.typeName?.name || annotation?.elementType?.typeName?.right?.name);
-        }
+    let annotation = node.value?.returnType?.typeAnnotation;
+    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 =
+          annotation.typeName?.right?.name ?? annotation.typeName?.name;
+      else if (annotation.type !== "TSArrayType"){
+        resultType = this._getTypeNameFromNode(annotation);
       }
-    }    
+      else if (annotation.elementType.type !== "TSTypeReference") {
+        isArray = true;
+        resultType = this._getTypeNameFromNode(annotation?.elementType);
+      } else {
+        isArray = true;
+        resultType =
+          annotation?.elementType?.typeName?.name ||
+          annotation?.elementType?.typeName?.right?.name;
+      } 
+    }
+
     resultType = typesToAnnotation[resultType];
-    if (isArray && resultType)
-      resultType = `list<${resultType}>`
-    return resultType;
+    if (isArray && resultType) resultType = `list`;
+    return resultType ?? 'dynamic';
   }
 
+
   _getTypeNameFromNode(typeNode) {
-    if (typeNode.type === 'TSTypeReference') {
+    if (typeNode.type === "TSTypeReference") {
       return typeNode.typeName.name;
-    } else if (typeNode.type === 'TSVoidKeyword') {
-      return 'void';
-    } else if (typeNode.type === 'TSNumberKeyword') {
-      return 'number';
-    } else if (typeNode.type === 'TSStringKeyword') {
-      return 'string';
-    } else if (typeNode.type === 'TSBooleanKeyword') {
-      return 'boolean';
+    } else if (typeNode.type === "TSVoidKeyword") {
+      return "void";
+    } else if (typeNode.type === "TSNumberKeyword") {
+      return "number";
+    } else if (typeNode.type === "TSStringKeyword") {
+      return "string";
+    } else if (typeNode.type === "TSBooleanKeyword") {
+      return "boolean";
     } else {
       return typeNode.type;
     }
@@ -330,11 +404,13 @@ class FuncGeneratorPlugin {
     fs.writeFileSync(this.options.outputPath, baseImport);
   }
 
-  _checkPackageFileForDecoratorsExport(packagePath){    
+  _checkPackageFileForDecoratorsExport(packagePath) {
     const content = fs.readFileSync(packagePath, "utf-8");
     const decoratorsExportRegex = /export\s*\*\s*from\s*'\.\/package\.g';/;
     if (!decoratorsExportRegex.test(content))
-      console.warn(`\nWARNING: Your package doesn't export package.g.ts file to package.ts \n please add "export * from './package.g';" to the package.ts file.\n`);
+      console.warn(
+        `\nWARNING: Your package doesn't export package.g.ts file to package.ts \n please add 'export * from './package.g';' to the package.ts file.\n`
+      );
   }
 
   _writeToPackageFile(filePath, imports, exp) {
@@ -352,14 +428,16 @@ class FuncGeneratorPlugin {
   _insertImports(importArray) {
     if (fs.existsSync(this.options.outputPath)) {
       const content = fs.readFileSync(this.options.outputPath, "utf-8");
-      if (content)
-        importArray.push(content);
+      if (content) importArray.push(content);
       const output = importArray.join("");
       fs.writeFileSync(this.options.outputPath, `${output}`, "utf-8");
-    } 
-    else
-      fs.writeFileSync(this.options.outputPath, `${baseImport}\n${importArray.join("")}`, "utf-8");
+    } else
+      fs.writeFileSync(
+        this.options.outputPath,
+        `${baseImport}\n${importArray.join("")}`,
+        "utf-8"
+      );
   }
 }
 
-module.exports = FuncGeneratorPlugin;
+module.exports = FuncGeneratorPlugin;