@aerokit/sdk 12.44.0 → 12.46.0

package/dist/cjs/db/store.js

@@ -121,24 +121,96 @@ class Store {
     return JSON.parse(result);
   }
   /**
-   * Queries all entries for a given entity name with pagination.
-   * @param name The entity/table name.
+   * Queries all entries for a given script with pagination.
+   * @param query The query script.
    * @param limit Maximum number of results to return.
    * @param offset Number of results to skip.
    * @returns An array of JavaScript objects.
    */
-  static query(name, limit = 100, offset = 0) {
-    const result = DataStoreFacade.query(name, limit, offset);
-    return JSON.parse(result);
+  static query(query, parameters, limit = 100, offset = 0) {
+    let arr = [];
+    if (parameters == null) {
+      arr = [];
+    } else if (typeof parameters === "string") {
+      try {
+        const parsed = JSON.parse(parameters);
+        if (!Array.isArray(parsed)) {
+          throw new Error("Input parameter string must represent a JSON array");
+        }
+        arr = parsed;
+      } catch (e) {
+        throw new Error("Invalid JSON parameters: " + e);
+      }
+    } else if (Array.isArray(parameters)) {
+      arr = parameters;
+    } else {
+      throw new Error("Parameters must be either an array or a JSON string");
+    }
+    if (arr.length === 0) {
+      const result = DataStoreFacade.query(query, null, limit, offset);
+      return JSON.parse(result);
+    }
+    const first = arr[0];
+    if (first && typeof first === "object" && "name" in first && "type" in first) {
+      const result = DataStoreFacade.queryNamed(query, JSON.stringify(arr), limit, offset);
+      return JSON.parse(result);
+    }
+    if (first && typeof first === "object" && "type" in first && !("name" in first)) {
+      const result = DataStoreFacade.query(query, JSON.stringify(arr), limit, offset);
+      return JSON.parse(result);
+    }
+    if (arr.every(
+      (v) => typeof v === "string" || typeof v === "number" || typeof v === "boolean" || v instanceof Date
+    )) {
+      const result = DataStoreFacade.query(query, JSON.stringify(arr), limit, offset);
+      return JSON.parse(result);
+    }
+    throw new Error("Unsupported parameter format: " + JSON.stringify(parameters));
   }
   /**
    * Queries all entries for a given entity name without pagination.
-   * @param name The entity/table name.
+   * @param query The entity/table name.
    * @returns An array of all JavaScript objects.
    */
-  static queryNative(name) {
-    const result = DataStoreFacade.queryNative(name);
-    return JSON.parse(result);
+  static queryNative(query, parameters, limit = 100, offset = 0) {
+    let arr = [];
+    if (parameters == null) {
+      arr = [];
+    } else if (typeof parameters === "string") {
+      try {
+        const parsed = JSON.parse(parameters);
+        if (!Array.isArray(parsed)) {
+          throw new Error("Input parameter string must represent a JSON array");
+        }
+        arr = parsed;
+      } catch (e) {
+        throw new Error("Invalid JSON parameters: " + e);
+      }
+    } else if (Array.isArray(parameters)) {
+      arr = parameters;
+    } else {
+      throw new Error("Parameters must be either an array or a JSON string");
+    }
+    if (arr.length === 0) {
+      const result = DataStoreFacade.queryNative(query, null, limit, offset);
+      return JSON.parse(result);
+    }
+    const first = arr[0];
+    if (first && typeof first === "object" && "name" in first && "type" in first) {
+      const result = DataStoreFacade.queryNativeNamed(query, JSON.stringify(arr), limit, offset);
+      return JSON.parse(result);
+    }
+    if (first && typeof first === "object" && "type" in first && !("name" in first)) {
+      const result = DataStoreFacade.queryNative(query, JSON.stringify(arr), limit, offset);
+      return JSON.parse(result);
+    }
+    if (arr.every(
+      (v) => typeof v === "string" || typeof v === "number" || typeof v === "boolean" || v instanceof Date
+    )) {
+      const result = DataStoreFacade.queryNative(query, JSON.stringify(arr), limit, offset);
+      return JSON.parse(result);
+    }
+    throw new Error("Unsupported parameter format: " + JSON.stringify(parameters));
   }
   // --- Metadata Getters ---
   /**
@@ -169,4 +241,4 @@ class Store {
 if (typeof module !== "undefined") {
   module.exports = Store;
 }
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/db/store.ts"],
  "sourcesContent": ["const DataStoreFacade = Java.type(\"org.eclipse.dirigible.components.api.db.DataStoreFacade\");\n\n/**\n * Defines the available comparison operators for query conditions.\n */\nexport enum Operator {\n\tEQ = \"=\", // Equals\n\tNE = \"<>\", // Not Equals\n\tGT = \">\", // Greater Than\n\tLT = \"<\", // Less Than\n\tGE = \">=\", // Greater Than or Equals\n\tLE = \"<=\", // Less Than or Equals\n\tLIKE = \"LIKE\", // SQL LIKE operator\n\tBETWEEN = \"BETWEEN\", // SQL BETWEEN operator (requires two values)\n\tIN = \"IN\" // SQL IN operator (requires a List or Array of values)\n}\n\n/**\n * Defines the direction for sorting.\n */\nexport enum Direction {\n\tASC = \"ASC\", // Ascending\n\tDESC = \"DESC\" // Descending\n}\n\n/**\n * Represents a single condition for filtering data.\n */\nexport interface Condition {\n\tpropertyName: string,\n\toperator: Operator,\n\tvalue: any | any[]\n}\n\n/**\n * Represents a single sorting instruction.\n */\nexport interface Sort {\n\tpropertyName: string,\n\tdirection: Direction\n}\n\n/**\n * Defines optional parameters for list and count operations.\n */\nexport interface Options {\n\tconditions?: Condition[],\n\tsorts?: Sort[],\n\tlimit?: number,\n\toffset?: number,\n\tlanguage?: string\n}\n\n/**\n * Facade class for interacting with the underlying Dirigible Data Store.\n * All methods serialize/deserialize JavaScript objects to/from JSON strings\n * before interacting with the native Java facade.\n */\nexport class Store {\n\n\t/**\n\t * Saves a new entry to the data store.\n\t * @param name The entity/table name.\n\t * @param entry The JavaScript object to save.\n\t * @returns The ID of the newly created entry (string or number).\n\t */\n\tpublic static save(name: string, entry: any): string | number {\n\t\treturn DataStoreFacade.save(name, JSON.stringify(entry));\n\t}\n\t\n\t/**\n\t * Inserts a new entry or updates an existing one if the ID is present.\n\t * @param name The entity/table name.\n\t * @param entry The JavaScript object to insert/update.\n\t */\n\tpublic static upsert(name: string, entry: any): void {\n\t\tDataStoreFacade.upsert(name, JSON.stringify(entry));\n\t}\n\t\n\t/**\n\t * Updates an existing entry.\n\t * @param name The entity/table name.\n\t * @param entry The JavaScript object with the ID and updated data.\n\t */\n\tpublic static update(name: string, entry: any): void {\n\t\tDataStoreFacade.update(name, JSON.stringify(entry));\n\t}\n\t\n\t/**\n\t * Lists entries based on optional filtering, sorting, and pagination options.\n\t * @param name The entity/table name.\n\t * @param options Optional {@link Options} for query execution.\n\t * @returns An array of JavaScript objects.\n\t */\n\tpublic static list(name: string, options?: Options): any[] {\n\t\tconst result = DataStoreFacade.list(name, options ? JSON.stringify(options) : null);\n\t\treturn JSON.parse(result);\n\t}\n\t\n\t/**\n\t * Counts the number of entries based on optional filtering options.\n\t * @param name The entity/table name.\n\t * @param options Optional {@link Options} for query execution.\n\t * @returns The count of matching entries.\n\t */\n\tpublic static count(name: string, options?: Options): number {\n\t\tconst optionsString = options ? JSON.stringify(options) : null;\n\t\tconst result = DataStoreFacade.count(name, optionsString);\n\t\treturn result;\n\t}\n\n\t/**\n\t * Retrieves a single entry by its ID.\n\t * @param name The entity/table name.\n\t * @param id The ID of the entry.\n\t * @returns The entry object, or undefined if not found.\n\t */\n\tpublic static get(name: string, id: any): any | undefined {\n\t\tconst result = DataStoreFacade.get(name, id);\n\t\t// Assuming the native API returns null/undefined or an empty JSON string if not found, \n\t\t// otherwise JSON.parse handles the conversion.\n\t\tif (result === null || result === undefined || result === \"\") {\n\t\t\treturn undefined;\n\t\t}\n\t\treturn JSON.parse(result);\n\t};\n\n\t/**\n\t * Deletes an entry by its ID.\n\t * @param name The entity/table name.\n\t * @param id The ID of the entry to remove.\n\t */\n\tpublic static remove(name: string, id: any): void {\n\t\tDataStoreFacade.deleteEntry(name, id);\n\t}\n\t\n\t/**\n\t * Finds entries matching an example object (query-by-example).\n\t * @param name The entity/table name.\n\t * @param example An object containing properties to match.\n\t * @param limit Maximum number of results to return.\n\t * @param offset Number of results to skip.\n\t * @returns An array of matching JavaScript objects.\n\t */\n\tpublic static find(name: string, example: any, limit: number = 100, offset: number = 0): any[] {\n\t\tconst result = DataStoreFacade.find(name, JSON.stringify(example), limit, offset);\n\t\treturn JSON.parse(result);\n\t}\n\t\n\t/**\n\t * Queries all entries for a given entity name with pagination.\n\t * @param name The entity/table name.\n\t * @param limit Maximum number of results to return.\n\t * @param offset Number of results to skip.\n\t * @returns An array of JavaScript objects.\n\t */\n\tpublic static query(name: string, limit: number = 100, offset: number = 0): any[] {\n\t\tconst result = DataStoreFacade.query(name, limit, offset);\n\t\treturn JSON.parse(result);\n\t}\n\t\n\t/**\n\t * Queries all entries for a given entity name without pagination.\n\t * @param name The entity/table name.\n\t * @returns An array of all JavaScript objects.\n\t */\n\tpublic static queryNative(name: string): any[] {\n\t\tconst result = DataStoreFacade.queryNative(name);\n\t\treturn JSON.parse(result);\n\t}\n\t\n\t// --- Metadata Getters ---\n\n\t/**\n\t * Gets the name of the entity associated with the store name.\n\t */\n\tpublic static getEntityName(name: string): string {\n\t\treturn DataStoreFacade.getEntityName(name);\n\t}\n\t\n\t/**\n\t * Gets the underlying database table name for the entity.\n\t */\n\tpublic static getTableName(name: string): string {\n\t\treturn DataStoreFacade.getTableName(name);\n\t}\n\t\t\n\t/**\n\t * Gets the property name used as the ID field in the entity object.\n\t */\n\tpublic static getIdName(name: string): string {\n\t\treturn DataStoreFacade.getIdName(name);\n\t}\n\t\t\t\n\t/**\n\t * Gets the underlying database column name used for the ID field.\n\t */\n\tpublic static getIdColumn(name: string): string {\n\t\treturn DataStoreFacade.getIdColumn(name);\n\t}\n\n}\n\n// @ts-ignore\nif (typeof module !== 'undefined') {\n\t// @ts-ignore\n\tmodule.exports = Store;\n}"],
  "mappings": "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",
  "names": ["Operator", "Direction"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/db/store.ts"],
  "sourcesContent": ["const DataStoreFacade = Java.type(\"org.eclipse.dirigible.components.api.db.DataStoreFacade\");\n\n/**\n * Defines the available comparison operators for query conditions.\n */\nexport enum Operator {\n\tEQ = \"=\", // Equals\n\tNE = \"<>\", // Not Equals\n\tGT = \">\", // Greater Than\n\tLT = \"<\", // Less Than\n\tGE = \">=\", // Greater Than or Equals\n\tLE = \"<=\", // Less Than or Equals\n\tLIKE = \"LIKE\", // SQL LIKE operator\n\tBETWEEN = \"BETWEEN\", // SQL BETWEEN operator (requires two values)\n\tIN = \"IN\" // SQL IN operator (requires a List or Array of values)\n}\n\n/**\n * Defines the direction for sorting.\n */\nexport enum Direction {\n\tASC = \"ASC\", // Ascending\n\tDESC = \"DESC\" // Descending\n}\n\n/**\n * Represents a single condition for filtering data.\n */\nexport interface Condition {\n\tpropertyName: string,\n\toperator: Operator,\n\tvalue: any | any[]\n}\n\n/**\n * Represents a single sorting instruction.\n */\nexport interface Sort {\n\tpropertyName: string,\n\tdirection: Direction\n}\n\n/**\n * Defines optional parameters for list and count operations.\n */\nexport interface Options {\n\tconditions?: Condition[],\n\tsorts?: Sort[],\n\tlimit?: number,\n\toffset?: number,\n\tlanguage?: string\n}\n\nimport { TypedQueryParameter, NamedQueryParameter } from './query';\n\n/**\n * Facade class for interacting with the underlying Dirigible Data Store.\n * All methods serialize/deserialize JavaScript objects to/from JSON strings\n * before interacting with the native Java facade.\n */\nexport class Store {\n\n\t/**\n\t * Saves a new entry to the data store.\n\t * @param name The entity/table name.\n\t * @param entry The JavaScript object to save.\n\t * @returns The ID of the newly created entry (string or number).\n\t */\n\tpublic static save(name: string, entry: any): string | number {\n\t\treturn DataStoreFacade.save(name, JSON.stringify(entry));\n\t}\n\t\n\t/**\n\t * Inserts a new entry or updates an existing one if the ID is present.\n\t * @param name The entity/table name.\n\t * @param entry The JavaScript object to insert/update.\n\t */\n\tpublic static upsert(name: string, entry: any): void {\n\t\tDataStoreFacade.upsert(name, JSON.stringify(entry));\n\t}\n\t\n\t/**\n\t * Updates an existing entry.\n\t * @param name The entity/table name.\n\t * @param entry The JavaScript object with the ID and updated data.\n\t */\n\tpublic static update(name: string, entry: any): void {\n\t\tDataStoreFacade.update(name, JSON.stringify(entry));\n\t}\n\t\n\t/**\n\t * Lists entries based on optional filtering, sorting, and pagination options.\n\t * @param name The entity/table name.\n\t * @param options Optional {@link Options} for query execution.\n\t * @returns An array of JavaScript objects.\n\t */\n\tpublic static list(name: string, options?: Options): any[] {\n\t\tconst result = DataStoreFacade.list(name, options ? JSON.stringify(options) : null);\n\t\treturn JSON.parse(result);\n\t}\n\t\n\t/**\n\t * Counts the number of entries based on optional filtering options.\n\t * @param name The entity/table name.\n\t * @param options Optional {@link Options} for query execution.\n\t * @returns The count of matching entries.\n\t */\n\tpublic static count(name: string, options?: Options): number {\n\t\tconst optionsString = options ? JSON.stringify(options) : null;\n\t\tconst result = DataStoreFacade.count(name, optionsString);\n\t\treturn result;\n\t}\n\n\t/**\n\t * Retrieves a single entry by its ID.\n\t * @param name The entity/table name.\n\t * @param id The ID of the entry.\n\t * @returns The entry object, or undefined if not found.\n\t */\n\tpublic static get(name: string, id: any): any | undefined {\n\t\tconst result = DataStoreFacade.get(name, id);\n\t\t// Assuming the native API returns null/undefined or an empty JSON string if not found, \n\t\t// otherwise JSON.parse handles the conversion.\n\t\tif (result === null || result === undefined || result === \"\") {\n\t\t\treturn undefined;\n\t\t}\n\t\treturn JSON.parse(result);\n\t};\n\n\t/**\n\t * Deletes an entry by its ID.\n\t * @param name The entity/table name.\n\t * @param id The ID of the entry to remove.\n\t */\n\tpublic static remove(name: string, id: any): void {\n\t\tDataStoreFacade.deleteEntry(name, id);\n\t}\n\t\n\t/**\n\t * Finds entries matching an example object (query-by-example).\n\t * @param name The entity/table name.\n\t * @param example An object containing properties to match.\n\t * @param limit Maximum number of results to return.\n\t * @param offset Number of results to skip.\n\t * @returns An array of matching JavaScript objects.\n\t */\n\tpublic static find(name: string, example: any, limit: number = 100, offset: number = 0): any[] {\n\t\tconst result = DataStoreFacade.find(name, JSON.stringify(example), limit, offset);\n\t\treturn JSON.parse(result);\n\t}\n\t\n\t/**\n\t * Queries all entries for a given script with pagination.\n\t * @param query The query script.\n\t * @param limit Maximum number of results to return.\n\t * @param offset Number of results to skip.\n\t * @returns An array of JavaScript objects.\n\t */\n\tpublic static query(query: string, parameters?: (string | number | boolean | Date | TypedQueryParameter | NamedQueryParameter)[], limit: number = 100, offset: number = 0): any[] {\n\t\tlet arr: any[] = [];\n\t    if (parameters == null) {\n\t      arr = [];\n\t    } else if (typeof parameters === \"string\") {\n\t      try {\n\t        const parsed = JSON.parse(parameters);\n\t        if (!Array.isArray(parsed)) {\n\t          throw new Error(\"Input parameter string must represent a JSON array\");\n\t        }\n\t        arr = parsed;\n\t      } catch (e) {\n\t        throw new Error(\"Invalid JSON parameters: \" + e);\n\t      }\n\t    } else if (Array.isArray(parameters)) {\n\t      arr = parameters;\n\t    } else {\n\t      throw new Error(\"Parameters must be either an array or a JSON string\");\n\t    }\n\n\t    if (arr.length === 0) {\n\t\t  const result = DataStoreFacade.query(query, null, limit, offset);\n\t\t  return JSON.parse(result);\n\t    }\n\n\t    const first = arr[0];\n\n\t    // NamedQueryParameter (has name + type)\n\t    if (first && typeof first === \"object\" && \"name\" in first && \"type\" in first) {\n\t\t  const result = DataStoreFacade.queryNamed(query, JSON.stringify(arr), limit, offset);\n\t\t  return JSON.parse(result);\n\t    }\n\n\t    // TypedQueryParameter (has type, no name)\n\t    if (first && typeof first === \"object\" && \"type\" in first && !(\"name\" in first)) {\n\t\t  const result = DataStoreFacade.query(query, JSON.stringify(arr), limit, offset);\n\t\t  return JSON.parse(result);\n\t    }\n\n\t    // Primitive array\n\t    if (\n\t      arr.every(\n\t        (v) =>\n\t          typeof v === \"string\" ||\n\t          typeof v === \"number\" ||\n\t          typeof v === \"boolean\" ||\n\t          v instanceof Date\n\t      )\n\t    ) {\n\t\t  const result = DataStoreFacade.query(query, JSON.stringify(arr), limit, offset);\n\t\t  return JSON.parse(result);\n\t    }\n\n\t    throw new Error(\"Unsupported parameter format: \" + JSON.stringify(parameters));\n\t}\n\t\n\t/**\n\t * Queries all entries for a given entity name without pagination.\n\t * @param query The entity/table name.\n\t * @returns An array of all JavaScript objects.\n\t */\n\tpublic static queryNative(query: string, parameters?: (string | number | boolean | Date | TypedQueryParameter | NamedQueryParameter)[], limit: number = 100, offset: number = 0): any[] {\n\t\tlet arr: any[] = [];\n\t\tif (parameters == null) {\n\t      arr = [];\n\t    } else if (typeof parameters === \"string\") {\n\t      try {\n\t        const parsed = JSON.parse(parameters);\n\t        if (!Array.isArray(parsed)) {\n\t          throw new Error(\"Input parameter string must represent a JSON array\");\n\t        }\n\t        arr = parsed;\n\t      } catch (e) {\n\t        throw new Error(\"Invalid JSON parameters: \" + e);\n\t      }\n\t    } else if (Array.isArray(parameters)) {\n\t      arr = parameters;\n\t    } else {\n\t      throw new Error(\"Parameters must be either an array or a JSON string\");\n\t    }\n\n\t    if (arr.length === 0) {\n\t\t  const result = DataStoreFacade.queryNative(query, null, limit, offset);\n\t\t  return JSON.parse(result);\n\t    }\n\n\t    const first = arr[0];\n\n\t    // NamedQueryParameter (has name + type)\n\t    if (first && typeof first === \"object\" && \"name\" in first && \"type\" in first) {\n\t\t  const result = DataStoreFacade.queryNativeNamed(query, JSON.stringify(arr), limit, offset);\n\t\t  return JSON.parse(result);\n\t    }\n\n\t    // TypedQueryParameter (has type, no name)\n\t    if (first && typeof first === \"object\" && \"type\" in first && !(\"name\" in first)) {\n\t\t  const result = DataStoreFacade.queryNative(query, JSON.stringify(arr), limit, offset);\n\t\t  return JSON.parse(result);\n\t    }\n\n\t    // Primitive array\n\t    if (\n\t      arr.every(\n\t        (v) =>\n\t          typeof v === \"string\" ||\n\t          typeof v === \"number\" ||\n\t          typeof v === \"boolean\" ||\n\t          v instanceof Date\n\t      )\n\t    ) {\n\t\t  const result = DataStoreFacade.queryNative(query, JSON.stringify(arr), limit, offset);\n\t\t  return JSON.parse(result);\n\t    }\n\n\t    throw new Error(\"Unsupported parameter format: \" + JSON.stringify(parameters));\n\t}\n\t\n\t// --- Metadata Getters ---\n\n\t/**\n\t * Gets the name of the entity associated with the store name.\n\t */\n\tpublic static getEntityName(name: string): string {\n\t\treturn DataStoreFacade.getEntityName(name);\n\t}\n\t\n\t/**\n\t * Gets the underlying database table name for the entity.\n\t */\n\tpublic static getTableName(name: string): string {\n\t\treturn DataStoreFacade.getTableName(name);\n\t}\n\t\t\n\t/**\n\t * Gets the property name used as the ID field in the entity object.\n\t */\n\tpublic static getIdName(name: string): string {\n\t\treturn DataStoreFacade.getIdName(name);\n\t}\n\t\t\t\n\t/**\n\t * Gets the underlying database column name used for the ID field.\n\t */\n\tpublic static getIdColumn(name: string): string {\n\t\treturn DataStoreFacade.getIdColumn(name);\n\t}\n\n}\n\n// @ts-ignore\nif (typeof module !== 'undefined') {\n\t// @ts-ignore\n\tmodule.exports = Store;\n}"],
  "mappings": "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",
  "names": ["Operator", "Direction"]
}


package/dist/cjs/db/update.js

@@ -25,19 +25,53 @@ class Update {
   /**
    * Executes a parameterized SQL update statement (INSERT, UPDATE, or DELETE).
    *
-   * @param sql The SQL statement to execute.
-   * @param parameters Optional array of parameters to bind to the SQL statement (replaces '?').
-   * These are serialized to JSON before being passed to the native API.
-   * @param datasourceName Optional name of the data source to use. Defaults to the primary data source.
+   * @param sql The SQL query to execute.
+   * @param parameters An optional array of values (primitives, TypedQueryParameter or NamedQueryParameter objects) to replace '?' or :paramName placeholders.
+   * @param datasourceName The name of the database connection to use (optional).
    * @returns The number of rows affected by the statement.
    */
   static execute(sql, parameters, datasourceName) {
-    const parametersJson = parameters ? JSON.stringify(parameters) : void 0;
-    const result = DatabaseFacade.update(sql, parametersJson, datasourceName);
-    return result;
+    let arr = [];
+    if (parameters == null) {
+      arr = [];
+    } else if (typeof parameters === "string") {
+      try {
+        const parsed = JSON.parse(parameters);
+        if (!Array.isArray(parsed)) {
+          throw new Error("Input parameter string must represent a JSON array");
+        }
+        arr = parsed;
+      } catch (e) {
+        throw new Error("Invalid JSON parameters: " + e);
+      }
+    } else if (Array.isArray(parameters)) {
+      arr = parameters;
+    } else {
+      throw new Error("Parameters must be either an array or a JSON string");
+    }
+    if (arr.length === 0) {
+      const result = DatabaseFacade.update(sql, null, datasourceName);
+      return result;
+    }
+    const first = arr[0];
+    if (first && typeof first === "object" && "name" in first && "type" in first) {
+      const result = DatabaseFacade.updateNamed(sql, JSON.stringify(arr), datasourceName);
+      return result;
+    }
+    if (first && typeof first === "object" && "type" in first && !("name" in first)) {
+      const result = DatabaseFacade.update(sql, JSON.stringify(arr), datasourceName);
+      return result;
+    }
+    if (arr.every(
+      (v) => typeof v === "string" || typeof v === "number" || typeof v === "boolean" || v instanceof Date
+    )) {
+      const result = DatabaseFacade.update(sql, JSON.stringify(arr), datasourceName);
+      return result;
+    }
+    throw new Error("Unsupported parameter format: " + JSON.stringify(parameters));
   }
 }
 if (typeof module !== "undefined") {
   module.exports = Update;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/dts/db/query.d.ts

@@ -5,9 +5,10 @@
 /**
  * Interface used to wrap complex or specific values for non-named queries.
  */
-export interface QueryParameter {
-    readonly value: any;
-}
+export type TypedQueryParameter = {
+    readonly type: string;
+    readonly value: unknown;
+};
 /**
  * Interface defining a parameter for a named query (using placeholders like :paramName).
  */
@@ -19,7 +20,7 @@ export interface NamedQueryParameter {
 /**
  * Interface to specify formatting options for the query result set.
  */
-export interface ResultParameter {
+export interface FormattingParameter {
     readonly dateFormat: string;
 }
 /**
@@ -27,15 +28,15 @@ export interface ResultParameter {
  */
 export declare class Query {
     /**
-     * Executes a standard SQL query with positional parameters ('?').
+     * Executes a standard SQL query with positional parameters. Parameters array supports primitives e.g. `[1, 'John', 34.56]` or objects in format either `{'type':'[DATA_TYPE]', 'value':[VALUE]}` or `{'name':'[string]', 'type':'[DATA_TYPE]', 'value':[VALUE]}` e.g. `[{'type':'CHAR', 'value':'ISBN19202323322'}]` or `[{'name': 'order_number', 'type':'CHAR', 'value':'ISBN19202323322'}]`
      *
      * @param sql The SQL query to execute.
-     * @param parameters An optional array of values (primitives or QueryParameter objects) to replace '?' placeholders.
+     * @param parameters An optional array of values (primitives, TypedQueryParameter or NamedQueryParameter objects) to replace '?' or :paramName placeholders.
      * @param datasourceName The name of the database connection to use (optional).
-     * @param resultParameter Optional formatting parameters for the result set (e.g., date format).
+     * @param formatting Optional formatting parameters for the result set (e.g., date format).
      * @returns An array of records representing the query results.
      */
-    static execute(sql: string, parameters?: (string | number | boolean | Date | QueryParameter)[], datasourceName?: string, resultParameter?: ResultParameter): any[];
+    static execute(sql: string, parameters?: (string | number | boolean | Date | TypedQueryParameter | NamedQueryParameter)[] | string, datasourceName?: string, formatting?: FormattingParameter): any[];
     /**
      * Executes a SQL query with named parameters (e.g., ":name", ":id").
      *

package/dist/dts/db/store.d.ts

@@ -44,6 +44,7 @@ export interface Options {
     offset?: number;
     language?: string;
 }
+import { TypedQueryParameter, NamedQueryParameter } from './query';
 /**
  * Facade class for interacting with the underlying Dirigible Data Store.
  * All methods serialize/deserialize JavaScript objects to/from JSON strings
@@ -106,19 +107,19 @@ export declare class Store {
      */
     static find(name: string, example: any, limit?: number, offset?: number): any[];
     /**
-     * Queries all entries for a given entity name with pagination.
-     * @param name The entity/table name.
+     * Queries all entries for a given script with pagination.
+     * @param query The query script.
      * @param limit Maximum number of results to return.
      * @param offset Number of results to skip.
      * @returns An array of JavaScript objects.
      */
-    static query(name: string, limit?: number, offset?: number): any[];
+    static query(query: string, parameters?: (string | number | boolean | Date | TypedQueryParameter | NamedQueryParameter)[], limit?: number, offset?: number): any[];
     /**
      * Queries all entries for a given entity name without pagination.
-     * @param name The entity/table name.
+     * @param query The entity/table name.
      * @returns An array of all JavaScript objects.
      */
-    static queryNative(name: string): any[];
+    static queryNative(query: string, parameters?: (string | number | boolean | Date | TypedQueryParameter | NamedQueryParameter)[], limit?: number, offset?: number): any[];
     /**
      * Gets the name of the entity associated with the store name.
      */

package/dist/dts/db/update.d.ts

@@ -1,21 +1,30 @@
 /**
  * Interface used for complex parameter types if needed, otherwise primitive types are used directly.
  */
-export interface UpdateParameter {
+export type TypedUpdateParameter = {
+    readonly type: string;
+    readonly value: unknown;
+};
+/**
+ * Interface defining a parameter for a named update query (using placeholders like :paramName).
+ */
+export interface NamedUpdateParameter {
+    readonly name: string;
+    readonly type: string;
     readonly value: any;
 }
 /**
  * Facade class for executing SQL UPDATE, INSERT, and DELETE statements.
+ * Parameters array supports primitives e.g. `[1, 'John', 34.56]` or objects in format either `{'type':'[DATA_TYPE]', 'value':[VALUE]}` or `{'name':'[string]', 'type':'[DATA_TYPE]', 'value':[VALUE]}` e.g. `[{'type':'CHAR', 'value':'ISBN19202323322'}]` or `[{'name': 'order_number', 'type':'CHAR', 'value':'ISBN19202323322'}]`
  */
 export declare class Update {
     /**
      * Executes a parameterized SQL update statement (INSERT, UPDATE, or DELETE).
      *
-     * @param sql The SQL statement to execute.
-     * @param parameters Optional array of parameters to bind to the SQL statement (replaces '?').
-     * These are serialized to JSON before being passed to the native API.
-     * @param datasourceName Optional name of the data source to use. Defaults to the primary data source.
+     * @param sql The SQL query to execute.
+     * @param parameters An optional array of values (primitives, TypedQueryParameter or NamedQueryParameter objects) to replace '?' or :paramName placeholders.
+     * @param datasourceName The name of the database connection to use (optional).
      * @returns The number of rows affected by the statement.
      */
-    static execute(sql: string, parameters?: (string | number | boolean | Date | UpdateParameter)[], datasourceName?: string): number;
+    static execute(sql: string, parameters?: (string | number | boolean | Date | TypedUpdateParameter | NamedUpdateParameter)[], datasourceName?: string): number;
 }