@mastra/libsql 0.0.4-alpha.4 → 0.0.5-alpha.0

package/dist/index.cjs

@@ -1,6 +1,7 @@
 'use strict';
 
 var client = require('@libsql/client');
+var utils = require('@mastra/core/utils');
 var vector = require('@mastra/core/vector');
 var filter = require('@mastra/core/vector/filter');
 var storage = require('@mastra/core/storage');
@@ -72,28 +73,53 @@ var LibSQLFilterTranslator = class extends filter.BaseFilterTranslator {
   //   };
   // }
 };
-
-// src/vector/sql-builder.ts
 var createBasicOperator = (symbol) => {
-  return (key) => ({
-    sql: `CASE 
-      WHEN ? IS NULL THEN json_extract(metadata, '$."${handleKey(key)}"') IS ${symbol === "=" ? "" : "NOT"} NULL
-      ELSE json_extract(metadata, '$."${handleKey(key)}"') ${symbol} ?
-    END`,
-    needsValue: true,
-    transformValue: (value) => {
-      return [value, value];
-    }
-  });
+  return (key, value) => {
+    const jsonPathKey = parseJsonPathKey(key);
+    return {
+      sql: `CASE 
+        WHEN ? IS NULL THEN json_extract(metadata, '$."${jsonPathKey}"') IS ${symbol === "=" ? "" : "NOT"} NULL
+        ELSE json_extract(metadata, '$."${jsonPathKey}"') ${symbol} ?
+      END`,
+      needsValue: true,
+      transformValue: () => {
+        return [value, value];
+      }
+    };
+  };
 };
 var createNumericOperator = (symbol) => {
-  return (key) => ({
-    sql: `CAST(json_extract(metadata, '$."${handleKey(key)}"') AS NUMERIC) ${symbol} ?`,
-    needsValue: true
-  });
+  return (key) => {
+    const jsonPathKey = parseJsonPathKey(key);
+    return {
+      sql: `CAST(json_extract(metadata, '$."${jsonPathKey}"') AS NUMERIC) ${symbol} ?`,
+      needsValue: true
+    };
+  };
 };
-var validateJsonArray = (key) => `json_valid(json_extract(metadata, '$."${handleKey(key)}"'))
-   AND json_type(json_extract(metadata, '$."${handleKey(key)}"')) = 'array'`;
+var validateJsonArray = (key) => `json_valid(json_extract(metadata, '$."${key}"'))
+   AND json_type(json_extract(metadata, '$."${key}"')) = 'array'`;
+var pattern = /json_extract\(metadata, '\$\."[^"]*"(\."[^"]*")*'\)/g;
+function buildElemMatchConditions(value) {
+  const conditions = Object.entries(value).map(([field, fieldValue]) => {
+    if (field.startsWith("$")) {
+      const { sql, values } = buildCondition("elem.value", { [field]: fieldValue });
+      const elemSql = sql.replace(pattern, "elem.value");
+      return { sql: elemSql, values };
+    } else if (typeof fieldValue === "object" && !Array.isArray(fieldValue)) {
+      const { sql, values } = buildCondition(field, fieldValue);
+      const elemSql = sql.replace(pattern, `json_extract(elem.value, '$."${field}"')`);
+      return { sql: elemSql, values };
+    } else {
+      const parsedFieldKey = utils.parseFieldKey(field);
+      return {
+        sql: `json_extract(elem.value, '$."${parsedFieldKey}"') = ?`,
+        values: [fieldValue]
+      };
+    }
+  });
+  return conditions;
+}
 var FILTER_OPERATORS = {
   $eq: createBasicOperator("="),
   $ne: createBasicOperator("!="),
@@ -102,90 +128,113 @@ var FILTER_OPERATORS = {
   $lt: createNumericOperator("<"),
   $lte: createNumericOperator("<="),
   // Array Operators
-  $in: (key, value) => ({
-    sql: `json_extract(metadata, '$."${handleKey(key)}"') IN (${value.map(() => "?").join(",")})`,
-    needsValue: true
-  }),
-  $nin: (key, value) => ({
-    sql: `json_extract(metadata, '$."${handleKey(key)}"') NOT IN (${value.map(() => "?").join(",")})`,
-    needsValue: true
-  }),
-  $all: (key) => ({
-    sql: `json_extract(metadata, '$."${handleKey(key)}"') = ?`,
-    needsValue: true,
-    transformValue: (value) => {
-      const arrayValue = Array.isArray(value) ? value : [value];
-      if (arrayValue.length === 0) {
-        return {
-          sql: "1 = 0",
-          values: []
-        };
-      }
-      return {
-        sql: `(
-          CASE
-            WHEN ${validateJsonArray(key)} THEN
-                NOT EXISTS (
-                    SELECT value 
-                    FROM json_each(?) 
-                    WHERE value NOT IN (
-                    SELECT value 
-                    FROM json_each(json_extract(metadata, '$."${handleKey(key)}"'))
-                )
+  $in: (key, value) => {
+    const jsonPathKey = parseJsonPathKey(key);
+    const arr = Array.isArray(value) ? value : [value];
+    if (arr.length === 0) {
+      return { sql: "1 = 0", needsValue: true, transformValue: () => [] };
+    }
+    const paramPlaceholders = arr.map(() => "?").join(",");
+    return {
+      sql: `(
+      CASE
+        WHEN ${validateJsonArray(jsonPathKey)} THEN
+          EXISTS (
+            SELECT 1 FROM json_each(json_extract(metadata, '$."${jsonPathKey}"')) as elem
+            WHERE elem.value IN (SELECT value FROM json_each(?))
+          )
+        ELSE json_extract(metadata, '$."${jsonPathKey}"') IN (${paramPlaceholders})
+      END
+    )`,
+      needsValue: true,
+      transformValue: () => [JSON.stringify(arr), ...arr]
+    };
+  },
+  $nin: (key, value) => {
+    const jsonPathKey = parseJsonPathKey(key);
+    const arr = Array.isArray(value) ? value : [value];
+    if (arr.length === 0) {
+      return { sql: "1 = 1", needsValue: true, transformValue: () => [] };
+    }
+    const paramPlaceholders = arr.map(() => "?").join(",");
+    return {
+      sql: `(
+      CASE
+        WHEN ${validateJsonArray(jsonPathKey)} THEN
+          NOT EXISTS (
+            SELECT 1 FROM json_each(json_extract(metadata, '$."${jsonPathKey}"')) as elem
+            WHERE elem.value IN (SELECT value FROM json_each(?))
+          )
+        ELSE json_extract(metadata, '$."${jsonPathKey}"') NOT IN (${paramPlaceholders})
+      END
+    )`,
+      needsValue: true,
+      transformValue: () => [JSON.stringify(arr), ...arr]
+    };
+  },
+  $all: (key, value) => {
+    const jsonPathKey = parseJsonPathKey(key);
+    let sql;
+    const arrayValue = Array.isArray(value) ? value : [value];
+    if (arrayValue.length === 0) {
+      sql = "1 = 0";
+    } else {
+      sql = `(
+      CASE
+        WHEN ${validateJsonArray(jsonPathKey)} THEN
+          NOT EXISTS (
+            SELECT value
+            FROM json_each(?)
+            WHERE value NOT IN (
+              SELECT value
+              FROM json_each(json_extract(metadata, '$."${jsonPathKey}"'))
             )
-            ELSE FALSE
-          END
-        )`,
-        values: [JSON.stringify(arrayValue)]
-      };
+          )
+        ELSE FALSE
+      END
+    )`;
     }
-  }),
-  $elemMatch: (key) => ({
-    sql: `json_extract(metadata, '$."${handleKey(key)}"') = ?`,
-    needsValue: true,
-    transformValue: (value) => {
-      if (typeof value !== "object" || Array.isArray(value)) {
-        throw new Error("$elemMatch requires an object with conditions");
-      }
-      const conditions = Object.entries(value).map(([field, fieldValue]) => {
-        if (field.startsWith("$")) {
-          const { sql, values } = buildCondition("elem.value", { [field]: fieldValue });
-          const pattern = /json_extract\(metadata, '\$\."[^"]*"(\."[^"]*")*'\)/g;
-          const elemSql = sql.replace(pattern, "elem.value");
-          return { sql: elemSql, values };
-        } else if (typeof fieldValue === "object" && !Array.isArray(fieldValue)) {
-          const { sql, values } = buildCondition(field, fieldValue);
-          const pattern = /json_extract\(metadata, '\$\."[^"]*"(\."[^"]*")*'\)/g;
-          const elemSql = sql.replace(pattern, `json_extract(elem.value, '$."${field}"')`);
-          return { sql: elemSql, values };
-        } else {
-          return {
-            sql: `json_extract(elem.value, '$."${field}"') = ?`,
-            values: [fieldValue]
-          };
+    return {
+      sql,
+      needsValue: true,
+      transformValue: () => {
+        if (arrayValue.length === 0) {
+          return [];
         }
-      });
-      return {
-        sql: `(
-          CASE
-            WHEN ${validateJsonArray(key)} THEN
-              EXISTS (
-                SELECT 1 
-                FROM json_each(json_extract(metadata, '$."${handleKey(key)}"')) as elem
-                WHERE ${conditions.map((c) => c.sql).join(" AND ")}
-              )
-            ELSE FALSE
-          END
-        )`,
-        values: conditions.flatMap((c) => c.values)
-      };
+        return [JSON.stringify(arrayValue)];
+      }
+    };
+  },
+  $elemMatch: (key, value) => {
+    const jsonPathKey = parseJsonPathKey(key);
+    if (typeof value !== "object" || Array.isArray(value)) {
+      throw new Error("$elemMatch requires an object with conditions");
     }
-  }),
+    const conditions = buildElemMatchConditions(value);
+    return {
+      sql: `(
+        CASE
+          WHEN ${validateJsonArray(jsonPathKey)} THEN
+            EXISTS (
+              SELECT 1
+              FROM json_each(json_extract(metadata, '$."${jsonPathKey}"')) as elem
+              WHERE ${conditions.map((c) => c.sql).join(" AND ")}
+            )
+          ELSE FALSE
+        END
+      )`,
+      needsValue: true,
+      transformValue: () => conditions.flatMap((c) => c.values)
+    };
+  },
   // Element Operators
-  $exists: (key) => ({
-    sql: `json_extract(metadata, '$."${handleKey(key)}"') IS NOT NULL`,
-    needsValue: false
-  }),
+  $exists: (key) => {
+    const jsonPathKey = parseJsonPathKey(key);
+    return {
+      sql: `json_extract(metadata, '$."${jsonPathKey}"') IS NOT NULL`,
+      needsValue: false
+    };
+  },
   // Logical Operators
   $and: (key) => ({
     sql: `(${key})`,
@@ -200,27 +249,30 @@ var FILTER_OPERATORS = {
     sql: `NOT (${key})`,
     needsValue: false
   }),
-  $size: (key, paramIndex) => ({
-    sql: `(
+  $size: (key, paramIndex) => {
+    const jsonPathKey = parseJsonPathKey(key);
+    return {
+      sql: `(
     CASE
-      WHEN json_type(json_extract(metadata, '$."${handleKey(key)}"')) = 'array' THEN 
-        json_array_length(json_extract(metadata, '$."${handleKey(key)}"')) = $${paramIndex}
+      WHEN json_type(json_extract(metadata, '$."${jsonPathKey}"')) = 'array' THEN 
+        json_array_length(json_extract(metadata, '$."${jsonPathKey}"')) = $${paramIndex}
       ELSE FALSE
     END
   )`,
-    needsValue: true
-  }),
+      needsValue: true
+    };
+  },
   //   /**
   //    * Regex Operators
   //    * Supports case insensitive and multiline
   //    */
   //   $regex: (key: string): FilterOperator => ({
-  //     sql: `json_extract(metadata, '$."${handleKey(key)}"') = ?`,
+  //     sql: `json_extract(metadata, '$."${toJsonPathKey(key)}"') = ?`,
   //     needsValue: true,
   //     transformValue: (value: any) => {
   //       const pattern = typeof value === 'object' ? value.$regex : value;
   //       const options = typeof value === 'object' ? value.$options || '' : '';
-  //       let sql = `json_extract(metadata, '$."${handleKey(key)}"')`;
+  //       let sql = `json_extract(metadata, '$."${toJsonPathKey(key)}"')`;
   //       // Handle multiline
   //       //   if (options.includes('m')) {
   //       //     sql = `REPLACE(${sql}, CHAR(10), '\n')`;
@@ -269,50 +321,64 @@ var FILTER_OPERATORS = {
   //       };
   //     },
   //   }),
-  $contains: (key) => ({
-    sql: `json_extract(metadata, '$."${handleKey(key)}"') = ?`,
-    needsValue: true,
-    transformValue: (value) => {
-      if (Array.isArray(value)) {
-        return {
-          sql: `(
-            SELECT ${validateJsonArray(key)}
-            AND EXISTS (
-              SELECT 1 
-              FROM json_each(json_extract(metadata, '$."${handleKey(key)}"')) as m
-              WHERE m.value IN (SELECT value FROM json_each(?))
-            )
-          )`,
-          values: [JSON.stringify(value)]
-        };
-      }
-      if (value && typeof value === "object") {
-        let traverse2 = function(obj, path = []) {
-          for (const [k, v] of Object.entries(obj)) {
-            const currentPath = [...path, k];
-            if (v && typeof v === "object" && !Array.isArray(v)) {
-              traverse2(v, currentPath);
-            } else {
-              paths.push(currentPath.join("."));
-              values.push(v);
-            }
-          }
-        };
-        const paths = [];
-        const values = [];
-        traverse2(value);
-        return {
-          sql: `(${paths.map((path) => `json_extract(metadata, '$."${handleKey(key)}"."${path}"') = ?`).join(" AND ")})`,
-          values
-        };
-      }
-      return value;
+  $contains: (key, value) => {
+    const jsonPathKey = parseJsonPathKey(key);
+    let sql;
+    if (Array.isArray(value)) {
+      sql = `(
+        SELECT ${validateJsonArray(jsonPathKey)}
+        AND EXISTS (
+          SELECT 1
+          FROM json_each(json_extract(metadata, '$."${jsonPathKey}"')) as m
+          WHERE m.value IN (SELECT value FROM json_each(?))
+        )
+      )`;
+    } else if (typeof value === "string") {
+      sql = `lower(json_extract(metadata, '$."${jsonPathKey}"')) LIKE '%' || lower(?) || '%' ESCAPE '\\'`;
+    } else {
+      sql = `json_extract(metadata, '$."${jsonPathKey}"') = ?`;
     }
-  })
+    return {
+      sql,
+      needsValue: true,
+      transformValue: () => {
+        if (Array.isArray(value)) {
+          return [JSON.stringify(value)];
+        }
+        if (typeof value === "object" && value !== null) {
+          return [JSON.stringify(value)];
+        }
+        if (typeof value === "string") {
+          return [escapeLikePattern(value)];
+        }
+        return [value];
+      }
+    };
+  }
+  /**
+   * $objectContains: True JSON containment for advanced use (deep sub-object match).
+   * Usage: { field: { $objectContains: { ...subobject } } }
+   */
+  // $objectContains: (key: string) => ({
+  //   sql: '', // Will be overridden by transformValue
+  //   needsValue: true,
+  //   transformValue: (value: any) => ({
+  //     sql: `json_type(json_extract(metadata, '$."${toJsonPathKey(key)}"')) = 'object'
+  //         AND json_patch(json_extract(metadata, '$."${toJsonPathKey(key)}"'), ?) = json_extract(metadata, '$."${toJsonPathKey(key)}"')`,
+  //     values: [JSON.stringify(value)],
+  //   }),
+  // }),
 };
-var handleKey = (key) => {
-  return key.replace(/\./g, '"."');
+function isFilterResult(obj) {
+  return obj && typeof obj === "object" && typeof obj.sql === "string" && Array.isArray(obj.values);
+}
+var parseJsonPathKey = (key) => {
+  const parsedKey = utils.parseFieldKey(key);
+  return parsedKey.replace(/\./g, '"."');
 };
+function escapeLikePattern(str) {
+  return str.replace(/([%_\\])/g, "\\$1");
+}
 function buildFilterQuery(filter) {
   if (!filter) {
     return { sql: "", values: [] };
@@ -405,8 +471,8 @@ var processOperator = (key, operator, operatorValue) => {
   if (!operatorResult.needsValue) {
     return { sql: operatorResult.sql, values: [] };
   }
-  const transformed = operatorResult.transformValue ? operatorResult.transformValue(operatorValue) : operatorValue;
-  if (transformed && typeof transformed === "object" && "sql" in transformed) {
+  const transformed = operatorResult.transformValue ? operatorResult.transformValue() : operatorValue;
+  if (isFilterResult(transformed)) {
     return transformed;
   }
   return {
@@ -446,10 +512,18 @@ var LibSQLVector = class extends vector.MastraVector {
     const params = this.normalizeArgs("query", args, ["minScore"]);
     try {
       const { indexName, queryVector, topK = 10, filter, includeVector = false, minScore = 0 } = params;
+      if (!Number.isInteger(topK) || topK <= 0) {
+        throw new Error("topK must be a positive integer");
+      }
+      if (!Array.isArray(queryVector) || !queryVector.every((x) => typeof x === "number" && Number.isFinite(x))) {
+        throw new Error("queryVector must be an array of finite numbers");
+      }
+      const parsedIndexName = utils.parseSqlIdentifier(indexName, "index name");
       const vectorStr = `[${queryVector.join(",")}]`;
       const translatedFilter = this.transformFilter(filter);
       const { sql: filterQuery, values: filterValues } = buildFilterQuery(translatedFilter);
       filterValues.push(minScore);
+      filterValues.push(topK);
       const query = `
         WITH vector_scores AS (
           SELECT
@@ -457,14 +531,14 @@ var LibSQLVector = class extends vector.MastraVector {
             (1-vector_distance_cos(embedding, '${vectorStr}')) as score,
             metadata
             ${includeVector ? ", vector_extract(embedding) as embedding" : ""}
-          FROM ${indexName}
+          FROM ${parsedIndexName}
           ${filterQuery}
         )
         SELECT *
         FROM vector_scores
         WHERE score > ?
         ORDER BY score DESC
-        LIMIT ${topK}`;
+        LIMIT ?`;
       const result = await this.turso.execute({
         sql: query,
         args: filterValues
@@ -483,10 +557,11 @@ var LibSQLVector = class extends vector.MastraVector {
     const { indexName, vectors, metadata, ids } = params;
     const tx = await this.turso.transaction("write");
     try {
+      const parsedIndexName = utils.parseSqlIdentifier(indexName, "index name");
       const vectorIds = ids || vectors.map(() => crypto.randomUUID());
       for (let i = 0; i < vectors.length; i++) {
         const query = `
-          INSERT INTO ${indexName} (vector_id, embedding, metadata)
+          INSERT INTO ${parsedIndexName} (vector_id, embedding, metadata)
           VALUES (?, vector32(?), ?)
           ON CONFLICT(vector_id) DO UPDATE SET
             embedding = vector32(?),
@@ -524,15 +599,13 @@ var LibSQLVector = class extends vector.MastraVector {
     const params = this.normalizeArgs("createIndex", args);
     const { indexName, dimension } = params;
     try {
-      if (!indexName.match(/^[a-zA-Z_][a-zA-Z0-9_]*$/)) {
-        throw new Error("Invalid index name format");
-      }
       if (!Number.isInteger(dimension) || dimension <= 0) {
         throw new Error("Dimension must be a positive integer");
       }
+      const parsedIndexName = utils.parseSqlIdentifier(indexName, "index name");
       await this.turso.execute({
         sql: `
-        CREATE TABLE IF NOT EXISTS ${indexName} (
+        CREATE TABLE IF NOT EXISTS ${parsedIndexName} (
           id SERIAL PRIMARY KEY,
           vector_id TEXT UNIQUE NOT NULL,
           embedding F32_BLOB(${dimension}),
@@ -543,8 +616,8 @@ var LibSQLVector = class extends vector.MastraVector {
       });
       await this.turso.execute({
         sql: `
-        CREATE INDEX IF NOT EXISTS ${indexName}_vector_idx
-        ON ${indexName} (libsql_vector_idx(embedding))
+        CREATE INDEX IF NOT EXISTS ${parsedIndexName}_vector_idx
+        ON ${parsedIndexName} (libsql_vector_idx(embedding))
       `,
         args: []
       });
@@ -554,10 +627,13 @@ var LibSQLVector = class extends vector.MastraVector {
     } finally {
     }
   }
-  async deleteIndex(indexName) {
+  async deleteIndex(...args) {
+    const params = this.normalizeArgs("deleteIndex", args);
+    const { indexName } = params;
     try {
+      const parsedIndexName = utils.parseSqlIdentifier(indexName, "index name");
       await this.turso.execute({
-        sql: `DROP TABLE IF EXISTS ${indexName}`,
+        sql: `DROP TABLE IF EXISTS ${parsedIndexName}`,
         args: []
       });
     } catch (error) {
@@ -582,8 +658,18 @@ var LibSQLVector = class extends vector.MastraVector {
       throw new Error(`Failed to list vector tables: ${error.message}`);
     }
   }
-  async describeIndex(indexName) {
+  /**
+   * Retrieves statistics about a vector index.
+   *
+   * @param params - The parameters for describing an index
+   * @param params.indexName - The name of the index to describe
+   * @returns A promise that resolves to the index statistics including dimension, count and metric
+   */
+  async describeIndex(...args) {
+    const params = this.normalizeArgs("describeIndex", args);
+    const { indexName } = params;
     try {
+      const parsedIndexName = utils.parseSqlIdentifier(indexName, "index name");
       const tableInfoQuery = `
         SELECT sql 
         FROM sqlite_master 
@@ -592,15 +678,15 @@ var LibSQLVector = class extends vector.MastraVector {
       `;
       const tableInfo = await this.turso.execute({
         sql: tableInfoQuery,
-        args: [indexName]
+        args: [parsedIndexName]
       });
       if (!tableInfo.rows[0]?.sql) {
-        throw new Error(`Table ${indexName} not found`);
+        throw new Error(`Table ${parsedIndexName} not found`);
       }
       const dimension = parseInt(tableInfo.rows[0].sql.match(/F32_BLOB\((\d+)\)/)?.[1] || "0");
       const countQuery = `
         SELECT COUNT(*) as count
-        FROM ${indexName};
+        FROM ${parsedIndexName};
       `;
       const countResult = await this.turso.execute({
         sql: countQuery,
@@ -634,10 +720,11 @@ var LibSQLVector = class extends vector.MastraVector {
       Please use updateVector() instead. 
       updateIndexById() will be removed on May 20th, 2025.`
     );
-    await this.updateVector(indexName, id, update);
+    await this.updateVector({ indexName, id, update });
   }
   /**
    * Updates a vector by its ID with the provided vector and/or metadata.
+   *
    * @param indexName - The name of the index containing the vector.
    * @param id - The ID of the vector to update.
    * @param update - An object containing the vector and/or metadata to update.
@@ -646,30 +733,33 @@ var LibSQLVector = class extends vector.MastraVector {
    * @returns A promise that resolves when the update is complete.
    * @throws Will throw an error if no updates are provided or if the update operation fails.
    */
-  async updateVector(indexName, id, update) {
+  async updateVector(...args) {
+    const params = this.normalizeArgs("updateVector", args);
+    const { indexName, id, update } = params;
     try {
+      const parsedIndexName = utils.parseSqlIdentifier(indexName, "index name");
       const updates = [];
-      const args = [];
+      const args2 = [];
       if (update.vector) {
         updates.push("embedding = vector32(?)");
-        args.push(JSON.stringify(update.vector));
+        args2.push(JSON.stringify(update.vector));
       }
       if (update.metadata) {
         updates.push("metadata = ?");
-        args.push(JSON.stringify(update.metadata));
+        args2.push(JSON.stringify(update.metadata));
       }
       if (updates.length === 0) {
         throw new Error("No updates provided");
       }
-      args.push(id);
+      args2.push(id);
       const query = `
-        UPDATE ${indexName}
+        UPDATE ${parsedIndexName}
         SET ${updates.join(", ")}
         WHERE vector_id = ?;
       `;
       await this.turso.execute({
         sql: query,
-        args
+        args: args2
       });
     } catch (error) {
       throw new Error(`Failed to update vector by id: ${id} for index: ${indexName}: ${error.message}`);
@@ -690,7 +780,7 @@ var LibSQLVector = class extends vector.MastraVector {
       Please use deleteVector() instead. 
       deleteIndexById() will be removed on May 20th, 2025.`
     );
-    await this.deleteVector(indexName, id);
+    await this.deleteVector({ indexName, id });
   }
   /**
    * Deletes a vector by its ID.
@@ -699,19 +789,24 @@ var LibSQLVector = class extends vector.MastraVector {
    * @returns A promise that resolves when the deletion is complete.
    * @throws Will throw an error if the deletion operation fails.
    */
-  async deleteVector(indexName, id) {
+  async deleteVector(...args) {
+    const params = this.normalizeArgs("deleteVector", args);
+    const { indexName, id } = params;
     try {
+      const parsedIndexName = utils.parseSqlIdentifier(indexName, "index name");
       await this.turso.execute({
-        sql: `DELETE FROM ${indexName} WHERE vector_id = ?`,
+        sql: `DELETE FROM ${parsedIndexName} WHERE vector_id = ?`,
         args: [id]
       });
     } catch (error) {
       throw new Error(`Failed to delete vector by id: ${id} for index: ${indexName}: ${error.message}`);
     }
   }
-  async truncateIndex(indexName) {
+  async truncateIndex(...args) {
+    const params = this.normalizeArgs("truncateIndex", args);
+    const { indexName } = params;
     await this.turso.execute({
-      sql: `DELETE FROM ${indexName}`,
+      sql: `DELETE FROM ${utils.parseSqlIdentifier(indexName, "index name")}`,
       args: []
     });
   }
@@ -733,22 +828,24 @@ var LibSQLStore = class extends storage.MastraStorage {
     this.client = client.createClient(config);
   }
   getCreateTableSQL(tableName, schema) {
+    const parsedTableName = utils.parseSqlIdentifier(tableName, "table name");
     const columns = Object.entries(schema).map(([name, col]) => {
+      const parsedColumnName = utils.parseSqlIdentifier(name, "column name");
       let type = col.type.toUpperCase();
       if (type === "TEXT") type = "TEXT";
       if (type === "TIMESTAMP") type = "TEXT";
       const nullable = col.nullable ? "" : "NOT NULL";
       const primaryKey = col.primaryKey ? "PRIMARY KEY" : "";
-      return `${name} ${type} ${nullable} ${primaryKey}`.trim();
+      return `${parsedColumnName} ${type} ${nullable} ${primaryKey}`.trim();
     });
     if (tableName === storage.TABLE_WORKFLOW_SNAPSHOT) {
-      const stmnt = `CREATE TABLE IF NOT EXISTS ${tableName} (
+      const stmnt = `CREATE TABLE IF NOT EXISTS ${parsedTableName} (
                 ${columns.join(",\n")},
                 PRIMARY KEY (workflow_name, run_id)
             )`;
       return stmnt;
     }
-    return `CREATE TABLE IF NOT EXISTS ${tableName} (${columns.join(", ")})`;
+    return `CREATE TABLE IF NOT EXISTS ${parsedTableName} (${columns.join(", ")})`;
   }
   async createTable({
     tableName,
@@ -764,8 +861,9 @@ var LibSQLStore = class extends storage.MastraStorage {
     }
   }
   async clearTable({ tableName }) {
+    const parsedTableName = utils.parseSqlIdentifier(tableName, "table name");
     try {
-      await this.client.execute(`DELETE FROM ${tableName}`);
+      await this.client.execute(`DELETE FROM ${parsedTableName}`);
     } catch (e) {
       if (e instanceof Error) {
         this.logger.error(e.message);
@@ -773,7 +871,8 @@ var LibSQLStore = class extends storage.MastraStorage {
     }
   }
   prepareStatement({ tableName, record }) {
-    const columns = Object.keys(record);
+    const parsedTableName = utils.parseSqlIdentifier(tableName, "table name");
+    const columns = Object.keys(record).map((col) => utils.parseSqlIdentifier(col, "column name"));
     const values = Object.values(record).map((v) => {
       if (typeof v === `undefined`) {
         return null;
@@ -785,7 +884,7 @@ var LibSQLStore = class extends storage.MastraStorage {
     });
     const placeholders = values.map(() => "?").join(", ");
     return {
-      sql: `INSERT OR REPLACE INTO ${tableName} (${columns.join(", ")}) VALUES (${placeholders})`,
+      sql: `INSERT OR REPLACE INTO ${parsedTableName} (${columns.join(", ")}) VALUES (${placeholders})`,
       args: values
     };
   }
@@ -813,10 +912,12 @@ var LibSQLStore = class extends storage.MastraStorage {
     }
   }
   async load({ tableName, keys }) {
-    const conditions = Object.entries(keys).map(([key]) => `${key} = ?`).join(" AND ");
+    const parsedTableName = utils.parseSqlIdentifier(tableName, "table name");
+    const parsedKeys = Object.keys(keys).map((key) => utils.parseSqlIdentifier(key, "column name"));
+    const conditions = parsedKeys.map((key) => `${key} = ?`).join(" AND ");
     const values = Object.values(keys);
     const result = await this.client.execute({
-      sql: `SELECT * FROM ${tableName} WHERE ${conditions} ORDER BY createdAt DESC LIMIT 1`,
+      sql: `SELECT * FROM ${parsedTableName} WHERE ${conditions} ORDER BY createdAt DESC LIMIT 1`,
       args: values
     });
     if (!result.rows || result.rows.length === 0) {