javonet-nodejs-sdk 2.6.2 → 2.6.4

package/dist/sdk/configuration/configResolvers/ConnectionStringConfigResolver.cjs

@@ -0,0 +1,123 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ConnectionStringConfigResolver_exports = {};
+__export(ConnectionStringConfigResolver_exports, {
+  ConnectionStringConfigResolver: () => ConnectionStringConfigResolver
+});
+module.exports = __toCommonJS(ConnectionStringConfigResolver_exports);
+var import_Config = require("../Config.cjs");
+var import_ConfigsDictionary = require("../ConfigsDictionary.cjs");
+var import_ActivationHelper = require("../../tools/ActivationHelper.cjs");
+var import_ConfigResolver = require("./ConfigResolver.cjs");
+class ConnectionStringConfigResolver extends import_ConfigResolver.ConfigResolver {
+  /**
+   * Parse and add multiple configuration lines from a connection string source.
+   * @param {any} priority
+   * @param {string} connectionStringSource
+   */
+  static addConfigs(priority, connectionStringSource) {
+    if (!connectionStringSource || String(connectionStringSource).trim() === "") {
+      throw new Error("Connection string source cannot be null or empty.");
+    }
+    const normalized = String(connectionStringSource).replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+    const lines = normalized.split("\n").map((l) => l.trim()).filter((l) => l.length > 0);
+    for (const line of lines) {
+      if (line.startsWith("#") || line.startsWith("//")) {
+        continue;
+      }
+      if (line.toLowerCase().startsWith("licensekey")) {
+        ConnectionStringConfigResolver._setLicenseKey(line);
+        continue;
+      }
+      try {
+        const keyValues = ConnectionStringConfigResolver._parseKeyValues(line);
+        const configName = keyValues.name;
+        const runtimeValue = keyValues.runtime;
+        if (!configName || String(configName).trim() === "") {
+          throw new Error("Missing or empty config name.");
+        }
+        if (!runtimeValue || String(runtimeValue).trim() === "") {
+          throw new Error("Missing or empty runtime.");
+        }
+        const runtimeName = import_ConfigResolver.ConfigResolver.tryParseRuntime(runtimeValue);
+        const hostValue = keyValues.host;
+        const connectionData = import_ConfigResolver.ConfigResolver.buildConnectionData(hostValue);
+        const plugins = keyValues.plugins || "";
+        const modules = keyValues.modules || "";
+        const config = new import_Config.Config(runtimeName, connectionData, plugins, modules);
+        import_ConfigsDictionary.ConfigsDictionary.addConfig(configName, priority, config);
+      } catch (ex) {
+        console.log(`Failed to parse config line: '${line}'. Reason: ${ex}`);
+        throw ex;
+      }
+    }
+  }
+  /**
+   * Extract and set temporary license key from a line like "licensekey=VALUE;..."
+   * @param {string} line
+   * @private
+   */
+  static _setLicenseKey(line) {
+    const eq = line.indexOf("=");
+    if (eq > 0 && eq < line.length - 1) {
+      let valuePortion = line.substring(eq + 1).trim();
+      const semicolon = valuePortion.indexOf(";");
+      if (semicolon >= 0) {
+        valuePortion = valuePortion.substring(0, semicolon).trim();
+      }
+      const hashIdx = valuePortion.indexOf("#");
+      if (hashIdx >= 0) {
+        valuePortion = valuePortion.substring(0, hashIdx).trim();
+      }
+      const slashes = valuePortion.indexOf("//");
+      if (slashes >= 0) {
+        valuePortion = valuePortion.substring(0, slashes).trim();
+      }
+      import_ActivationHelper.ActivationHelper.setTemporaryLicenseKey(valuePortion);
+    }
+  }
+  /**
+   * Parse semicolon-separated key=value tokens into an object.
+   * Ignores malformed tokens and logs them.
+   * @param {string} line
+   * @returns {Record<string, string>}
+   * @private
+   */
+  static _parseKeyValues(line) {
+    const result = {};
+    const segments = line.split(";").map((s) => s.trim()).filter((s) => s.length > 0);
+    for (const segment of segments) {
+      const eq = segment.indexOf("=");
+      if (eq <= 0 || eq === segment.length - 1) {
+        console.log(`Ignoring malformed token '${segment}' in line: ${line}`);
+        continue;
+      }
+      const key = segment.substring(0, eq).trim().toLowerCase();
+      const value = segment.substring(eq + 1).trim();
+      if (key) {
+        result[key] = value;
+      }
+    }
+    return result;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ConnectionStringConfigResolver
+});

package/dist/sdk/configuration/configResolvers/JsonConfigResolver.cjs

@@ -0,0 +1,125 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var JsonConfigResolver_exports = {};
+__export(JsonConfigResolver_exports, {
+  JsonConfigResolver: () => JsonConfigResolver
+});
+module.exports = __toCommonJS(JsonConfigResolver_exports);
+var import_Config = require("../Config.cjs");
+var import_ConfigsDictionary = require("../ConfigsDictionary.cjs");
+var import_ConfigResolver = require("./ConfigResolver.cjs");
+var import_ActivationHelper = require("../../tools/ActivationHelper.cjs");
+class JsonConfigResolver extends import_ConfigResolver.ConfigResolver {
+  /**
+   * Parse and add configurations from a JSON object.
+   * @param {any} priority
+   * @param {Record<string, unknown>} jsonObject
+   */
+  static addConfigs(priority, jsonObject) {
+    if (jsonObject == null) {
+      throw new Error("json_object cannot be None");
+    }
+    if (typeof jsonObject !== "object" || Array.isArray(jsonObject)) {
+      throw new Error("Root JSON element must be a dict/object.");
+    }
+    const licenseKey = (
+      /** @type {Record<string, unknown>} */
+      jsonObject.licenseKey
+    );
+    if (typeof licenseKey === "string") {
+      import_ActivationHelper.ActivationHelper.setTemporaryLicenseKey(licenseKey.trim());
+    }
+    const configs = (
+      /** @type {Record<string, unknown>} */
+      jsonObject.configurations
+    );
+    if (typeof configs !== "object" || configs == null || Array.isArray(configs)) {
+      throw new Error("JSON must contain 'configurations' object.");
+    }
+    for (const [configName, cfg] of Object.entries(
+      /** @type {Record<string, unknown>} */
+      configs
+    )) {
+      try {
+        if (typeof cfg !== "object" || cfg == null || Array.isArray(cfg)) {
+          throw new Error("Configuration value must be an object/dict.");
+        }
+        const runtimeValue = JsonConfigResolver._getRequiredString(
+          /** @type {Record<string, unknown>} */
+          cfg,
+          "runtime"
+        );
+        const runtimeName = import_ConfigResolver.ConfigResolver.tryParseRuntime(runtimeValue);
+        const host = JsonConfigResolver._getOptionalString(
+          /** @type {Record<string, unknown>} */
+          cfg,
+          "host"
+        );
+        const connectionData = import_ConfigResolver.ConfigResolver.buildConnectionData(host);
+        const plugins = JsonConfigResolver._getOptionalString(
+          /** @type {Record<string, unknown>} */
+          cfg,
+          "plugins"
+        );
+        const modules = JsonConfigResolver._getOptionalString(
+          /** @type {Record<string, unknown>} */
+          cfg,
+          "modules"
+        );
+        const config = new import_Config.Config(runtimeName, connectionData, plugins, modules);
+        import_ConfigsDictionary.ConfigsDictionary.addConfig(configName, priority, config);
+      } catch (ex) {
+        console.log(`Failed to add config '${configName}': ${ex}`);
+      }
+    }
+  }
+  /**
+   * Get a required string property from an object, trimmed.
+   * Throws if missing or empty.
+   * @param {Record<string, unknown>} obj
+   * @param {string} property
+   * @returns {string}
+   * @private
+   */
+  static _getRequiredString(obj, property) {
+    const value = obj[property];
+    if (typeof value !== "string" || value.trim() === "") {
+      throw new Error(`Missing or invalid '${property}' property.`);
+    }
+    return value.trim();
+  }
+  /**
+   * Get an optional string property; return empty string when missing or not a string.
+   * @param {Record<string, unknown>} obj
+   * @param {string} property
+   * @returns {string}
+   * @private
+   */
+  static _getOptionalString(obj, property) {
+    const value = obj[property];
+    if (typeof value === "string") {
+      return value;
+    }
+    return "";
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  JsonConfigResolver
+});

package/dist/sdk/configuration/configResolvers/YamlConfigResolver.cjs

@@ -0,0 +1,125 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var YamlConfigResolver_exports = {};
+__export(YamlConfigResolver_exports, {
+  YamlConfigResolver: () => YamlConfigResolver
+});
+module.exports = __toCommonJS(YamlConfigResolver_exports);
+var import_js_yaml = __toESM(require("js-yaml"), 1);
+var import_Config = require("../Config.cjs");
+var import_ConfigsDictionary = require("../ConfigsDictionary.cjs");
+var import_ConfigResolver = require("./ConfigResolver.cjs");
+var import_ActivationHelper = require("../../tools/ActivationHelper.cjs");
+class YamlConfigResolver extends import_ConfigResolver.ConfigResolver {
+  /**
+   * Parse YAML string and add configurations.
+   * @param {any} priority
+   * @param {string} yamlString
+   */
+  static addConfigs(priority, yamlString) {
+    if (!yamlString || String(yamlString).trim() === "") {
+      throw new Error("YAML string cannot be null or empty.");
+    }
+    let data;
+    try {
+      data = import_js_yaml.default.load(String(yamlString));
+    } catch (ex) {
+      throw new SyntaxError(`Failed to parse YAML: ${ex}`);
+    }
+    if (typeof data !== "object" || data == null || Array.isArray(data)) {
+      throw new SyntaxError("Root YAML node must be a mapping.");
+    }
+    const root = (
+      /** @type {RootYaml} */
+      data
+    );
+    const licenseKey = root.licenseKey;
+    if (typeof licenseKey === "string") {
+      import_ActivationHelper.ActivationHelper.temporaryLicenseKey = licenseKey.trim();
+    }
+    const configs = root.configurations;
+    if (typeof configs !== "object" || configs == null || Array.isArray(configs)) {
+      throw new Error("YAML must contain 'configurations' mapping.");
+    }
+    for (const [configName, cfg] of Object.entries(configs)) {
+      if (typeof configName !== "string" || configName.trim() === "") {
+        console.log("Skipping entry with empty config name.");
+        continue;
+      }
+      if (typeof cfg !== "object" || cfg == null || Array.isArray(cfg)) {
+        console.log(`Skipping '${configName}': value is not a mapping.`);
+        continue;
+      }
+      try {
+        const runtimeValue = YamlConfigResolver._getRequiredString(cfg, "runtime");
+        const runtimeName = import_ConfigResolver.ConfigResolver.tryParseRuntime(runtimeValue);
+        const host = YamlConfigResolver._getOptionalString(cfg, "host");
+        const connectionData = import_ConfigResolver.ConfigResolver.buildConnectionData(host);
+        const plugins = YamlConfigResolver._getOptionalString(cfg, "plugins");
+        const modules = YamlConfigResolver._getOptionalString(cfg, "modules");
+        const config = new import_Config.Config(runtimeName, connectionData, plugins, modules);
+        import_ConfigsDictionary.ConfigsDictionary.addConfig(configName, priority, config);
+      } catch (ex) {
+        console.log(`Failed to add config '${configName}': ${ex}`);
+      }
+    }
+  }
+  /**
+   * Get required string from mapping, trimmed. Throws if missing/invalid.
+   * @param {Record<string, unknown>} mapping
+   * @param {string} key
+   * @returns {string}
+   * @private
+   */
+  static _getRequiredString(mapping, key) {
+    const value = mapping[key];
+    if (typeof value !== "string" || value.trim() === "") {
+      throw new Error(`Missing or invalid '${key}' property.`);
+    }
+    return value.trim();
+  }
+  /**
+   * Get optional string from mapping, or empty string if missing/not a string.
+   * @param {Record<string, unknown>} mapping
+   * @param {string} key
+   * @returns {string}
+   * @private
+   */
+  static _getOptionalString(mapping, key) {
+    const value = mapping[key];
+    if (typeof value === "string") {
+      return value;
+    }
+    return "";
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  YamlConfigResolver
+});

package/dist/sdk/tools/ComplexTypeResolver.cjs

@@ -0,0 +1,114 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ComplexTypeResolver_exports = {};
+__export(ComplexTypeResolver_exports, {
+  ComplexTypeResolver: () => ComplexTypeResolver
+});
+module.exports = __toCommonJS(ComplexTypeResolver_exports);
+var import_Runtime = require("../../utils/Runtime.cjs");
+var import_RuntimeName = require("../../utils/RuntimeName.cjs");
+var import_ActivatorDetails = require("../ActivatorDetails.cjs");
+var import_InvocationContext = require("../InvocationContext.cjs");
+var import_JavaTypeParsingFunctions = require("./typeParsingFunctions/JavaTypeParsingFunctions.cjs");
+var import_NetcoreTypeParsingFunctions = require("./typeParsingFunctions/NetcoreTypeParsingFunctions.cjs");
+var import_NodejsTypeParsingFunctions = require("./typeParsingFunctions/NodejsTypeParsingFunctions.cjs");
+var import_PythonTypeParsingFunctions = require("./typeParsingFunctions/PythonTypeParsingFunctions.cjs");
+const import_meta = {};
+const dynamicImport = (0, import_Runtime.getRequire)(import_meta.url);
+class ComplexTypeResolver {
+  /** @type {Map<string, ActivatorDetails>} */
+  #typeMap = /* @__PURE__ */ new Map();
+  /** @type {Map<number, Map<string, Function>>} */
+  #typeParsingFunctions = /* @__PURE__ */ new Map([
+    [import_RuntimeName.RuntimeName.Netcore, import_NetcoreTypeParsingFunctions.NetcoreTypeParsingFunctions],
+    [import_RuntimeName.RuntimeName.Jvm, import_JavaTypeParsingFunctions.JavaTypeParsingFunctions],
+    [import_RuntimeName.RuntimeName.Nodejs, import_NodejsTypeParsingFunctions.NodejsTypeParsingFunctions],
+    [import_RuntimeName.RuntimeName.Python, import_PythonTypeParsingFunctions.PythonTypeParsingFunctions],
+    [import_RuntimeName.RuntimeName.Python27, import_PythonTypeParsingFunctions.PythonTypeParsingFunctions]
+  ]);
+  /**
+   * Register a custom type mapping
+   * @param {string} resultType - The type name from the target runtime
+   * @param {Function} type - The JavaScript constructor function
+   * @param {any[]} [args] - Default arguments for the constructor
+   */
+  register(resultType, type, args) {
+    if (!this.#typeMap.has(resultType)) {
+      this.#typeMap.set(resultType, new import_ActivatorDetails.ActivatorDetails(type, args));
+    }
+  }
+  /**
+   * Convert InvocationContext result to appropriate JavaScript type
+   * @param {InvocationContext} ic - The invocation context
+   * @returns {any} The converted result
+   */
+  convertResult(ic) {
+    const runtimeName = ic.getRuntimeName();
+    const resultType = ic.getResultType();
+    const runtimeDict = this.#typeParsingFunctions.get(runtimeName);
+    if (runtimeDict) {
+      const parsingFunc = runtimeDict.get(resultType);
+      if (parsingFunc) {
+        return parsingFunc(ic);
+      }
+    }
+    const activatorDetails = this.#typeMap.get(resultType);
+    if (!activatorDetails) {
+      throw new Error(`No type registered for key '${resultType}'.`);
+    }
+    return new /** @type {any} */
+    activatorDetails.type(...activatorDetails.arguments);
+  }
+  /**
+   * Resolve type from string name and optional module
+   * @param {string} typeName - Name of the type to resolve
+   * @param {string} [moduleName] - Optional module name to import from
+   * @returns {Function} The resolved type/constructor function
+   */
+  static resolveType(typeName, moduleName) {
+    if (moduleName) {
+      try {
+        const module2 = dynamicImport(moduleName);
+        const typeObj2 = module2[typeName];
+        if (!typeObj2) {
+          throw new Error(`Type '${typeName}' not found in module '${moduleName}'`);
+        }
+        return typeObj2;
+      } catch (error) {
+        throw new Error(
+          `Failed to resolve type '${typeName}' from module '${moduleName}': ${/** @type {Error} */
+          error.message}`
+        );
+      }
+    }
+    const globalScope = typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : {};
+    const typeObj = (
+      /** @type {Record<string, any>} */
+      globalScope[typeName]
+    );
+    if (!typeObj) {
+      throw new Error(`Type '${typeName}' not found in global scope`);
+    }
+    return typeObj;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ComplexTypeResolver
+});

package/dist/sdk/tools/JsonResolver.cjs

@@ -42,8 +42,10 @@ let fs = null;
 class JsonResolver {
   /** @type {ConfigSource} */
   jsonObject;
-  /** @type {string | ConfigSource} */
+  /** @type {string} */
   configSource;
+  /** @type {boolean} */
+  isConfigSourcePath = false;
   /**
    * @param {string | ConfigSource} configSource
    */
@@ -149,6 +151,7 @@ class JsonResolver {
         fs = requireDynamic("fs");
       }
       if (fs?.existsSync(configSource)) {
+        this.isConfigSourcePath = true;
         const jsonText = fs.readFileSync(configSource, "utf8");
         if (isValidJson(jsonText)) {
           const parsedFromFile = JSON.parse(jsonText);

package/dist/sdk/tools/typeParsingFunctions/JavaTypeParsingFunctions.cjs

@@ -0,0 +1,44 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var JavaTypeParsingFunctions_exports = {};
+__export(JavaTypeParsingFunctions_exports, {
+  JavaTypeParsingFunctions: () => JavaTypeParsingFunctions,
+  parseDate: () => parseDate
+});
+module.exports = __toCommonJS(JavaTypeParsingFunctions_exports);
+var import_TypeParsingUtils = require("./TypeParsingUtils.cjs");
+function parseDate(invocationContext) {
+  const result = invocationContext.getInstanceField("epochMilli").execute();
+  const action = (timestamp) => {
+    if (!timestamp) {
+      throw new Error("getTime.getValue() returned null");
+    }
+    return new Date(
+      /** @type {number} */
+      timestamp * 1e4
+    );
+  };
+  return (0, import_TypeParsingUtils.handleResultWithAction)(result, action);
+}
+const JavaTypeParsingFunctions = /* @__PURE__ */ new Map([["System.DateTime", parseDate]]);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  JavaTypeParsingFunctions,
+  parseDate
+});

package/dist/sdk/tools/typeParsingFunctions/NetcoreTypeParsingFunctions.cjs

@@ -0,0 +1,44 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var NetcoreTypeParsingFunctions_exports = {};
+__export(NetcoreTypeParsingFunctions_exports, {
+  NetcoreTypeParsingFunctions: () => NetcoreTypeParsingFunctions,
+  parseDate: () => parseDate
+});
+module.exports = __toCommonJS(NetcoreTypeParsingFunctions_exports);
+var import_TypeParsingUtils = require("./TypeParsingUtils.cjs");
+function parseDate(invocationContext) {
+  const result = invocationContext.getInstanceField("Ticks").execute();
+  const action = (timestamp) => {
+    if (!timestamp) {
+      throw new Error("getTime.getValue() returned null");
+    }
+    return new Date(
+      /** @type {number} */
+      timestamp
+    );
+  };
+  return (0, import_TypeParsingUtils.handleResultWithAction)(result, action);
+}
+const NetcoreTypeParsingFunctions = /* @__PURE__ */ new Map([["System.DateTime", parseDate]]);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NetcoreTypeParsingFunctions,
+  parseDate
+});

package/dist/sdk/tools/typeParsingFunctions/NodejsTypeParsingFunctions.cjs

@@ -0,0 +1,44 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var NodejsTypeParsingFunctions_exports = {};
+__export(NodejsTypeParsingFunctions_exports, {
+  NodejsTypeParsingFunctions: () => NodejsTypeParsingFunctions,
+  parseDate: () => parseDate
+});
+module.exports = __toCommonJS(NodejsTypeParsingFunctions_exports);
+var import_TypeParsingUtils = require("./TypeParsingUtils.cjs");
+function parseDate(invocationContext) {
+  const result = invocationContext.invokeInstanceMethod("getTime").execute();
+  const action = (timestamp) => {
+    if (!timestamp) {
+      throw new Error("getTime.getValue() returned null");
+    }
+    return new Date(
+      /** @type {number} */
+      timestamp
+    );
+  };
+  return (0, import_TypeParsingUtils.handleResultWithAction)(result, action);
+}
+const NodejsTypeParsingFunctions = /* @__PURE__ */ new Map([["Date", parseDate]]);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NodejsTypeParsingFunctions,
+  parseDate
+});