@evolu/common 6.0.1-preview.2 → 6.0.1-preview.21

package/src/Sqlite.ts

@@ -1,17 +1,10 @@
+import { Brand } from "./Brand.js";
 import { ConsoleDep } from "./Console.js";
+import { EncryptionKey } from "./Crypto.js";
 import { createTransferableError, TransferableError } from "./Error.js";
 import { err, ok, Result, tryAsync, trySync } from "./Result.js";
-import {
-  Boolean,
-  Null,
-  Number,
-  SimpleName,
-  String,
-  transform,
-  Uint8Array,
-  union,
-} from "./Type.js";
-import { Brand, Predicate, IntentionalNever } from "./Types.js";
+import { Null, Number, SimpleName, String, Uint8Array, union } from "./Type.js";
+import { IntentionalNever, Predicate } from "./Types.js";
 
 /**
  * SQLite driver interface. This is the minimal interface that platform-specific
@@ -33,6 +26,7 @@ export interface CreateSqliteDriverDep {
 
 export interface SqliteDriverOptions {
   memory?: boolean;
+  encryptionKey?: EncryptionKey | undefined;
 }
 
 /**
@@ -148,13 +142,13 @@ export const createSqlite =
         exec: (query) =>
           trySync(
             () => {
-              deps.console?.log("[sql]", query);
+              deps.console?.log("[sql]", { query });
 
               const result = maybeLogSqliteQueryExecutionTime(query, () =>
                 driver.exec(query, isSqlMutation(query.sql)),
               );
 
-              deps.console?.log("[sql]", result);
+              deps.console?.log("[sql]", { result });
 
               return result as IntentionalNever;
             },
@@ -366,8 +360,38 @@ const isSqlMutationRegEx = new RegExp(
   "i",
 );
 
+/**
+ * Removes SQL line comments (--) from a SQL string without using regex to avoid
+ * ReDoS vulnerabilities.
+ */
+const removeSqlComments = (sql: string): string => {
+  let result = "";
+  let i = 0;
+
+  while (i < sql.length) {
+    // Check for comment start
+    if (i < sql.length - 1 && sql[i] === "-" && sql[i + 1] === "-") {
+      // Skip until end of line or end of string
+      i += 2;
+      while (i < sql.length && sql[i] !== "\n") {
+        i++;
+      }
+      // Keep the newline if present
+      if (i < sql.length && sql[i] === "\n") {
+        result += "\n";
+        i++;
+      }
+    } else {
+      result += sql[i];
+      i++;
+    }
+  }
+
+  return result;
+};
+
 export const isSqlMutation: Predicate<string> = (sql) =>
-  isSqlMutationRegEx.test(sql.replace(/--.*$/gm, ""));
+  isSqlMutationRegEx.test(removeSqlComments(sql));
 
 export interface SqliteQueryPlanRow {
   id: number;
@@ -385,13 +409,14 @@ export const explainSqliteQueryPlan =
     if (!result.ok) return result;
 
     // eslint-disable-next-line no-console
-    console.log("ExplainQueryPlan", query);
+    console.log("[explainSqliteQueryPlan]", query);
     // eslint-disable-next-line no-console
     console.log(
       drawSqliteQueryPlan(
         result.value.rows as unknown as Array<SqliteQueryPlanRow>,
       ),
     );
+
     return ok();
   };
 
@@ -415,15 +440,26 @@ const drawSqliteQueryPlan = (rows: Array<SqliteQueryPlanRow>): string =>
 
 /**
  * SQLite represents boolean values using `0` (false) and `1` (true) instead of
- * a dedicated boolean type. This transform Type ensures that values conform to
- * SQLite's boolean representation.
+ * a dedicated boolean type.
+ *
+ * Use {@link sqliteTrue} and {@link sqliteFalse} constants for better
+ * readability.
  *
  * See: https://www.sqlite.org/quirks.html#no_separate_boolean_datatype
  */
-export const SqliteBoolean = transform(
-  Boolean,
-  union(0, 1),
-  (value) => ok(value ? (1 as const) : (0 as const)),
-  (value) => value === 1,
-);
+export const SqliteBoolean = union(0, 1);
 export type SqliteBoolean = typeof SqliteBoolean.Type;
+
+/**
+ * Represents the {@link SqliteBoolean} value for `true`.
+ *
+ * See {@link SqliteBoolean}.
+ */
+export const sqliteTrue = 1;
+
+/**
+ * Represents the {@link SqliteBoolean} value for `false`.
+ *
+ * See {@link SqliteBoolean}.
+ */
+export const sqliteFalse = 0;