@velarscript-labs/sqlite 0.2.2 → 0.3.2

package/dist/velar-library.json

@@ -4,15 +4,15 @@
   "abiVersion": 1,
   "package": {
     "name": "@velarscript-labs/sqlite",
-    "version": "0.2.2"
+    "version": "0.3.2"
   },
   "target": "node",
-  "compilerVersion": "0.14.2",
+  "compilerVersion": "0.15.0",
   "sourceEntry": "src/index.vel",
   "sources": [
     {
       "path": "src/index.vel",
-      "sha256": "e6272cf2f7d0ca88034fcf3deb7db7c9e63158165017167933b79a1887cad390"
+      "sha256": "d35ec69e071fdeab0e379a78209c7f075cabf1b9b5148c9ba033a325e9c482b6"
     }
   ],
   "entry": {
@@ -20,9 +20,9 @@
     "sourceMap": "index.js.map",
     "interface": "index.veli.json",
     "sha256": {
-      "javascript": "271affd5cabaf9b34c49a706e7965d9c3942f2ddffe9e921d7bdc092102ebffb",
-      "sourceMap": "62cb96e139d5bbe00c042081a0f2c713efe54b54a0ebd030be92db182ea0f59e",
-      "interface": "31f47fb9c50ce51bcdb1ab035aa2d279687ff4adba06eeab9c463f1f7e683869"
+      "javascript": "33086d56ae3878ed41d4c31405ce57e17b8aca65ec3160a9a82ceada7b4b49d7",
+      "sourceMap": "d2e01a92404964ef4674985191acf85be17185a1ea75fb2369f5acaf6fb8aecf",
+      "interface": "93ed6516f8b9c501b068b4550424e472d536e1e7a9b3451bba536b3c3e736012"
     }
   }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@velarscript-labs/sqlite",
-  "version": "0.2.2",
-  "description": "Bounded asynchronous SQLite capability for VelarScript Node applications.",
+  "version": "0.3.2",
+  "description": "Injection-resistant bounded SQLite capability for VelarScript Node applications.",
   "license": "Apache-2.0",
   "type": "module",
   "files": [
@@ -17,7 +17,7 @@
     "test": "velar test"
   },
   "engines": {
-    "node": ">=24"
+    "node": ">=24.12"
   },
   "repository": {
     "type": "git",
@@ -34,9 +34,10 @@
     "entry": "src/index.vel",
     "artifacts": { "node": "dist/velar-library.json" },
     "targets": ["node"],
-    "requires": {"capabilities": ["node"], "language": ">=0.13 <0.15"}
+    "requires": {"capabilities": ["node"], "language": ">=0.15 <0.16"}
   },
   "dependencies": {
-    "@velarscript-labs/database": "0.2.2"
+    "@velarscript-labs/database": "0.3.2",
+    "sqlite3-parser": "0.7.1"
   }
 }

package/src/index.vel

@@ -1,14 +1,25 @@
 /// Per-connection bounds. Every operation is serialized through one Worker;
 /// queueCapacity bounds admitted operations waiting for that connection.
-import {DatabaseExecutor} from "@velarscript-labs/database"
+import {DatabaseExecutor, DatabaseStatement, trustedSql} from "@velarscript-labs/database"
+
+export enum SqliteJournalMode:
+    delete
+    truncate
+    persist
+    memory
+    wal
+    off
 
 export type SqliteOptions:
     busyTimeoutMilliseconds: number?
     queueCapacity: number?
     maxRows: number?
     maxResultBytes: number?
+    statementCacheCapacity: number?
+    journalMode: SqliteJournalMode?
+    readOnly: bool?
 
-extern js()`
+extern js`
     import { AsyncLocalStorage } from "node:async_hooks";
     import { Worker } from "node:worker_threads";
 
@@ -51,21 +62,31 @@ extern js()`
 
     function checkedOptions(value) {
       if (value === null || typeof value !== "object" || Array.isArray(value)) throw new TypeError("SQLite options must be a record");
-      const allowed = new Set(["busyTimeoutMilliseconds", "queueCapacity", "maxRows", "maxResultBytes"]);
+      const allowed = new Set(["busyTimeoutMilliseconds", "queueCapacity", "maxRows", "maxResultBytes", "statementCacheCapacity", "journalMode", "readOnly"]);
       for (const key of Object.keys(value)) if (!allowed.has(key)) throw new TypeError("Unknown SQLite option " + key);
+      const journalModes = new Set(["delete", "truncate", "persist", "memory", "wal", "off"]);
+      const journalMode = value.journalMode == null ? null : value.journalMode;
+      if (journalMode !== null && (typeof journalMode !== "string" || !journalModes.has(journalMode))) throw new TypeError("SQLite journalMode must name a supported mode");
+      if (value.readOnly != null && typeof value.readOnly !== "boolean") throw new TypeError("SQLite readOnly must be bool");
+      if (value.readOnly === true && journalMode !== null) throw new TypeError("SQLite readOnly connections cannot change journalMode");
       return {
         busyTimeoutMilliseconds: integer(value.busyTimeoutMilliseconds, 2000, 1, 60000, "SQLite busy timeout"),
         queueCapacity: integer(value.queueCapacity, 64, 1, 1024, "SQLite queue capacity"),
         maxRows: integer(value.maxRows, 10000, 1, 1000000, "SQLite row limit"),
         maxResultBytes: integer(value.maxResultBytes, 64 * 1024 * 1024, 1, 128 * 1024 * 1024, "SQLite result byte limit"),
+        statementCacheCapacity: integer(value.statementCacheCapacity, 128, 1, 1024, "SQLite statement cache capacity"),
+        journalMode,
+        readOnly: value.readOnly === true,
       };
     }
 
     function workerMain() {
       const { Buffer } = require("node:buffer");
       const { parentPort, workerData } = require("node:worker_threads");
-      const { DatabaseSync } = require("node:sqlite");
+      const { DatabaseSync, constants } = require("node:sqlite");
+      const { parseStmt } = require("sqlite3-parser");
       let database = null;
+      let statements = null;
       let closed = false;
 
       function failure(message, code, operation, retryable = false) {
@@ -89,13 +110,6 @@ extern js()`
         };
       }
 
-      function sqlText(value, operation) {
-        if (typeof value !== "string" || value.length === 0 || value.length > 1024 * 1024 || value.includes("\0")) {
-          throw failure("SQLite SQL must be non-empty text no longer than 1 MiB", "SQLITE_INPUT", operation);
-        }
-        return value;
-      }
-
       function parameter(value, budget) {
         if (value === null) return null;
         if (typeof value === "boolean") return value ? 1 : 0;
@@ -124,6 +138,29 @@ extern js()`
         return output;
       }
 
+      function statementParts(rawFragments, rawParameters, operation) {
+        if (!Array.isArray(rawFragments) || rawFragments.length !== rawParameters.length + 1 || rawFragments.length > 1000) {
+          throw failure("SQLite statements require exactly one more SQL fragment than bound parameters", "SQLITE_INPUT", operation);
+        }
+        let sourceBytes = 0;
+        const fragments = rawFragments.map(fragment => {
+          if (typeof fragment !== "string" || fragment.includes("\0") || fragment.includes("?")) {
+            throw failure("SQLite SQL fragments must be text without NUL or raw parameter placeholders", "SQLITE_INPUT", operation);
+          }
+          sourceBytes += Buffer.byteLength(fragment, "utf8");
+          return fragment;
+        });
+        if (sourceBytes === 0 || sourceBytes > 1024 * 1024) throw failure("SQLite SQL must be non-empty text no longer than 1 MiB", "SQLITE_INPUT", operation);
+        const bound = parameters(rawParameters);
+        const source = fragments.join("?");
+        const parsed = parseStmt(source);
+        if (parsed.status !== "ok") {
+          const message = parsed.errors.length === 0 ? "invalid statement" : parsed.errors[0].message;
+          throw failure("SQLite requires exactly one valid statement: " + message, "SQLITE_INPUT", operation);
+        }
+        return { fragments, bound };
+      }
+
       function count(value, label) {
         const number = typeof value === "bigint" ? Number(value) : value;
         if (!Number.isSafeInteger(number) || number < 0) throw failure(label + " is outside VelarScript's safe integer range", "SQLITE_INTEGER_RANGE", "result");
@@ -165,30 +202,24 @@ extern js()`
         return output;
       }
 
-      function statement(sql, operation) {
-        const prepared = database.prepare(sqlText(sql, operation));
-        if (typeof prepared.setReadBigInts === "function") prepared.setReadBigInts(true);
-        return prepared;
-      }
-
       function execute(message) {
-        const prepared = statement(message.sql, "execute");
-        const result = prepared.run(...parameters(message.params));
+        const statement = statementParts(message.fragments, message.params, "execute");
+        const result = statements.run(statement.fragments, ...statement.bound);
         return count(result.changes, "SQLite affected row count");
       }
 
       function one(message) {
-        const prepared = statement(message.sql, "one");
-        const row = prepared.get(...parameters(message.params));
+        const statement = statementParts(message.fragments, message.params, "one");
+        const row = statements.get(statement.fragments, ...statement.bound);
         if (row === undefined) return null;
         return resultRow(row, { value: 0 });
       }
 
       function all(message) {
-        const prepared = statement(message.sql, "all");
+        const statement = statementParts(message.fragments, message.params, "all");
         const rows = [];
         const budget = { value: 0 };
-        for (const row of prepared.iterate(...parameters(message.params))) {
+        for (const row of statements.iterate(statement.fragments, ...statement.bound)) {
           if (rows.length >= workerData.maxRows) throw failure("SQLite result exceeds the connection row limit", "SQLITE_ROW_LIMIT", "all");
           rows.push(resultRow(row, budget));
         }
@@ -227,8 +258,39 @@ extern js()`
       }
 
       try {
-        database = new DatabaseSync(workerData.path, { timeout: workerData.busyTimeoutMilliseconds });
-        database.exec("PRAGMA foreign_keys = ON");
+        database = new DatabaseSync(workerData.path, {
+          timeout: workerData.busyTimeoutMilliseconds,
+          readOnly: workerData.readOnly,
+          enableForeignKeyConstraints: true,
+          enableDoubleQuotedStringLiterals: false,
+          allowExtension: false,
+          readBigInts: true,
+          allowBareNamedParameters: false,
+          allowUnknownNamedParameters: false,
+          defensive: true,
+          limits: {
+            length: workerData.maxResultBytes,
+            sqlLength: 1024 * 1024,
+            column: 2000,
+            exprDepth: 1000,
+            compoundSelect: 500,
+            vdbeOp: 250000,
+            functionArg: 1000,
+            attach: 0,
+            likePatternLength: 50000,
+            variableNumber: 999,
+            triggerDepth: 100,
+          },
+        });
+        database.enableDefensive(true);
+        database.enableLoadExtension(false);
+        database.setAuthorizer((actionCode, arg1, arg2) => {
+          if (actionCode === constants.SQLITE_ATTACH || actionCode === constants.SQLITE_DETACH) return constants.SQLITE_DENY;
+          if (actionCode === constants.SQLITE_FUNCTION && typeof arg2 === "string" && arg2.toLowerCase() === "load_extension") return constants.SQLITE_DENY;
+          return constants.SQLITE_OK;
+        });
+        statements = database.createTagStore(workerData.statementCacheCapacity);
+        if (workerData.journalMode !== null) database.exec("PRAGMA journal_mode = " + workerData.journalMode.toUpperCase());
         parentPort.postMessage({ kind: "ready" });
       } catch (error) {
         parentPort.postMessage({ kind: "ready", error: errorData(error, "open") });
@@ -261,13 +323,13 @@ extern js()`
       state.pending.clear();
     }
 
-    function request(state, operation, sql = "", params = []) {
+    function request(state, operation, fragments = [""], params = []) {
       if (state.closed) return Promise.reject(new NativeSqliteError("SQLite connection is closed", "SQLITE_CLOSED", operation));
       const id = state.nextId++;
       return new Promise((resolve, reject) => {
         state.pending.set(id, { resolve, reject });
         try {
-          state.worker.postMessage({ id, operation, sql, params });
+          state.worker.postMessage({ id, operation, fragments, params });
         } catch (error) {
           state.pending.delete(id);
           reject(error);
@@ -287,11 +349,11 @@ extern js()`
       return state;
     }
 
-    function transactionRequest(transaction, operation, sql = "", params = []) {
+    function transactionRequest(transaction, operation, fragments = [""], params = []) {
       const state = transactionStateOf(transaction);
       if (state.busy) return Promise.reject(new NativeSqliteConcurrencyError("SQLite transaction operations must be awaited one at a time"));
       state.busy = true;
-      return request(state.connection, operation, sql, params).finally(() => { state.busy = false; });
+      return request(state.connection, operation, fragments, params).finally(() => { state.busy = false; });
     }
 
     function enqueue(state, operation) {
@@ -310,9 +372,9 @@ extern js()`
         transactionStates.set(this, state);
       }
 
-      execute(sql, params = []) { return transactionRequest(this, "execute", sql, params); }
-      one(sql, params = []) { return transactionRequest(this, "one", sql, params); }
-      all(sql, params = []) { return transactionRequest(this, "all", sql, params); }
+      execute(fragments, params = []) { return transactionRequest(this, "execute", fragments, params); }
+      one(fragments, params = []) { return transactionRequest(this, "one", fragments, params); }
+      all(fragments, params = []) { return transactionRequest(this, "all", fragments, params); }
     }
 
     export class NativeSqliteConnection {
@@ -321,19 +383,19 @@ extern js()`
         connectionStates.set(this, state);
       }
 
-      execute(sql, params = []) {
+      execute(fragments, params = []) {
         const state = stateOf(this);
-        return enqueue(state, () => request(state, "execute", sql, params));
+        return enqueue(state, () => request(state, "execute", fragments, params));
       }
 
-      one(sql, params = []) {
+      one(fragments, params = []) {
         const state = stateOf(this);
-        return enqueue(state, () => request(state, "one", sql, params));
+        return enqueue(state, () => request(state, "one", fragments, params));
       }
 
-      all(sql, params = []) {
+      all(fragments, params = []) {
         const state = stateOf(this);
-        return enqueue(state, () => request(state, "all", sql, params));
+        return enqueue(state, () => request(state, "all", fragments, params));
       }
 
       transaction(operation) {
@@ -448,14 +510,14 @@ extern js()`
         const message: string
 
     export class NativeSqliteTransaction:
-        async def execute(sql: string, params: List<unknown> = []) -> number
-        async def one(sql: string, params: List<unknown> = []) -> unknown
-        async def all(sql: string, params: List<unknown> = []) -> List<unknown>
+        async def execute(fragments: readonly List<string>, params: readonly List<unknown> = []) -> number
+        async def one(fragments: readonly List<string>, params: readonly List<unknown> = []) -> unknown
+        async def all(fragments: readonly List<string>, params: readonly List<unknown> = []) -> List<unknown>
 
     export class NativeSqliteConnection:
-        async def execute(sql: string, params: List<unknown> = []) -> number
-        async def one(sql: string, params: List<unknown> = []) -> unknown
-        async def all(sql: string, params: List<unknown> = []) -> List<unknown>
+        async def execute(fragments: readonly List<string>, params: readonly List<unknown> = []) -> number
+        async def one(fragments: readonly List<string>, params: readonly List<unknown> = []) -> unknown
+        async def all(fragments: readonly List<string>, params: readonly List<unknown> = []) -> List<unknown>
         async def transaction(operation: (NativeSqliteTransaction) -> Promise<null>) -> null
         async def close() -> null
 
@@ -475,160 +537,156 @@ export class SqliteError extends Error:
         self.retryable = retryable
 
 export class SqliteBackpressureError extends SqliteError:
-    constructor(message: string = "SQLite queue is full"):
-        super(message, "SQLITE_BACKPRESSURE", "queue", true)
+    constructor(message: string = "SQLite queue is full"): super(message, "SQLITE_BACKPRESSURE", "queue", true)
 
 export class SqliteConcurrencyError extends SqliteError:
     constructor(message: string = "SQLite connection cannot be used from its transaction callback"):
         super(message, "SQLITE_CONCURRENCY", "transaction", true)
 
 def sqliteFailure(error: NativeSqliteError) -> SqliteError:
-    if error is NativeSqliteBackpressureError:
-        return SqliteBackpressureError(error.message)
-    if error is NativeSqliteConcurrencyError:
-        return SqliteConcurrencyError(error.message)
-    if error is NativeSqliteError:
-        return SqliteError(error.message, error.sqliteCode, error.operation, error.retryable)
+    if error is NativeSqliteBackpressureError: return SqliteBackpressureError(error.message)
+    if error is NativeSqliteConcurrencyError: return SqliteConcurrencyError(error.message)
+    if error is NativeSqliteError: return SqliteError(error.message, error.sqliteCode, error.operation, error.retryable)
     return SqliteError(error.message)
 
+/// Produces a SQLite literal only for grammar positions where bound parameters
+/// are not legal, such as schema defaults and PRAGMA assignments. Ordinary
+/// query values must still use sqlParameter/sqlTuple/sqlRows.
+export def sqliteLiteral(value: unknown) -> DatabaseStatement:
+    if value == null: return trustedSql("NULL")
+    if value is bool: return trustedSql(value ? "1" : "0")
+    if value is string: return trustedSql("'" + value.replaceAll("'", "''") + "'")
+    if value is number:
+        assert value.isFinite() else "SQLite numeric literals must be finite"
+        assert not value.isInteger() or (value >= -9007199254740991 and value <= 9007199254740991) else "SQLite integer literals must be safe integers"
+        return trustedSql(str(value))
+    throw Error("SQLite literals support only null, bool, string, and finite number")
+
+/// Quotes one SQLite identifier as a single name. Qualified names must compose
+/// separately quoted identifiers around trusted punctuation.
+export def sqliteIdentifier(value: string) -> DatabaseStatement:
+    assert not value.isBlank() and value.size <= 255 and not value.has(Text.fromCodePoint(0)) else "SQLite identifiers must be non-blank text with no NUL and no longer than 255 characters"
+    return trustedSql(`"` + value.replaceAll(`"`, `""`) + `"`)
+
 export class SqliteTransaction:
-    constructor(private const native: NativeSqliteTransaction):
-        pass
+    constructor(private const native: NativeSqliteTransaction): pass
 
-    async def execute(sql: string, params: List<unknown> = []) -> number:
-        try:
-            return await self.native.execute(sql, params)
+    async def execute(statement: DatabaseStatement) -> number:
+        const data = statement.data()
+        try: return await self.native.execute(data.fragments, data.parameters)
         catch error:
-            if error is NativeSqliteError:
-                throw sqliteFailure(error)
+            if error is NativeSqliteError: throw sqliteFailure(error)
             throw SqliteError(error.message)
 
     /// Projects this transaction into the engine-neutral functional operation layer.
     def executor() -> DatabaseExecutor:
-        async def executeStatement(text: string, parameters: List<unknown>) -> number:
-            return await self.execute(text, parameters)
+        async def executeStatement(statement: DatabaseStatement) -> number: return await self.execute(statement)
 
-        async def oneRow(text: string, parameters: List<unknown>) -> unknown:
-            try:
-                return await self.native.one(text, parameters)
+        async def oneRow(statement: DatabaseStatement) -> unknown:
+            const data = statement.data()
+            try: return await self.native.one(data.fragments, data.parameters)
             catch error:
-                if error is NativeSqliteError:
-                    throw sqliteFailure(error)
+                if error is NativeSqliteError: throw sqliteFailure(error)
                 throw SqliteError(error.message)
 
-        async def allRows(text: string, parameters: List<unknown>) -> List<unknown>:
-            try:
-                return await self.native.all(text, parameters)
+        async def allRows(statement: DatabaseStatement) -> List<unknown>:
+            const data = statement.data()
+            try: return await self.native.all(data.fragments, data.parameters)
             catch error:
-                if error is NativeSqliteError:
-                    throw sqliteFailure(error)
+                if error is NativeSqliteError: throw sqliteFailure(error)
                 throw SqliteError(error.message)
 
         return {execute: executeStatement, one: oneRow, all: allRows}
 
-    async def one<T>(sql: string, RowType: Type<T>, params: List<unknown> = []) -> T?:
+    async def one<T>(statement: DatabaseStatement, RowType: Type<T>) -> T?:
+        const data = statement.data()
         try:
-            const row = await self.native.one(sql, params)
-            if row == null:
-                return null
+            const row = await self.native.one(data.fragments, data.parameters)
+            if row == null: return null
             return RowType.parse(row)
         catch error:
-            if error is NativeSqliteError:
-                throw sqliteFailure(error)
+            if error is NativeSqliteError: throw sqliteFailure(error)
             throw SqliteError(error.message)
 
-    async def all<T>(sql: string, RowType: Type<T>, params: List<unknown> = []) -> List<T>:
+    async def all<T>(statement: DatabaseStatement, RowType: Type<T>) -> List<T>:
+        const data = statement.data()
         try:
-            const rows = await self.native.all(sql, params)
+            const rows = await self.native.all(data.fragments, data.parameters)
             return rows.map(row => RowType.parse(row))
         catch error:
-            if error is NativeSqliteError:
-                throw sqliteFailure(error)
+            if error is NativeSqliteError: throw sqliteFailure(error)
             throw SqliteError(error.message)
 
 export class SqliteConnection:
-    constructor(private const native: NativeSqliteConnection):
-        pass
+    constructor(private const native: NativeSqliteConnection): pass
 
-    async def execute(sql: string, params: List<unknown> = []) -> number:
-        try:
-            return await self.native.execute(sql, params)
+    async def execute(statement: DatabaseStatement) -> number:
+        const data = statement.data()
+        try: return await self.native.execute(data.fragments, data.parameters)
         catch error:
-            if error is NativeSqliteError:
-                throw sqliteFailure(error)
+            if error is NativeSqliteError: throw sqliteFailure(error)
             throw SqliteError(error.message)
 
     /// Projects this connection into the engine-neutral functional operation layer.
     def executor() -> DatabaseExecutor:
-        async def executeStatement(text: string, parameters: List<unknown>) -> number:
-            return await self.execute(text, parameters)
+        async def executeStatement(statement: DatabaseStatement) -> number: return await self.execute(statement)
 
-        async def oneRow(text: string, parameters: List<unknown>) -> unknown:
-            try:
-                return await self.native.one(text, parameters)
+        async def oneRow(statement: DatabaseStatement) -> unknown:
+            const data = statement.data()
+            try: return await self.native.one(data.fragments, data.parameters)
             catch error:
-                if error is NativeSqliteError:
-                    throw sqliteFailure(error)
+                if error is NativeSqliteError: throw sqliteFailure(error)
                 throw SqliteError(error.message)
 
-        async def allRows(text: string, parameters: List<unknown>) -> List<unknown>:
-            try:
-                return await self.native.all(text, parameters)
+        async def allRows(statement: DatabaseStatement) -> List<unknown>:
+            const data = statement.data()
+            try: return await self.native.all(data.fragments, data.parameters)
             catch error:
-                if error is NativeSqliteError:
-                    throw sqliteFailure(error)
+                if error is NativeSqliteError: throw sqliteFailure(error)
                 throw SqliteError(error.message)
 
         return {execute: executeStatement, one: oneRow, all: allRows}
 
-    async def one<T>(sql: string, RowType: Type<T>, params: List<unknown> = []) -> T?:
+    async def one<T>(statement: DatabaseStatement, RowType: Type<T>) -> T?:
+        const data = statement.data()
         try:
-            const row = await self.native.one(sql, params)
-            if row == null:
-                return null
+            const row = await self.native.one(data.fragments, data.parameters)
+            if row == null: return null
             return RowType.parse(row)
         catch error:
-            if error is NativeSqliteError:
-                throw sqliteFailure(error)
+            if error is NativeSqliteError: throw sqliteFailure(error)
             throw SqliteError(error.message)
 
-    async def all<T>(sql: string, RowType: Type<T>, params: List<unknown> = []) -> List<T>:
+    async def all<T>(statement: DatabaseStatement, RowType: Type<T>) -> List<T>:
+        const data = statement.data()
         try:
-            const rows = await self.native.all(sql, params)
+            const rows = await self.native.all(data.fragments, data.parameters)
             return rows.map(row => RowType.parse(row))
         catch error:
-            if error is NativeSqliteError:
-                throw sqliteFailure(error)
+            if error is NativeSqliteError: throw sqliteFailure(error)
             throw SqliteError(error.message)
 
     async def transaction<T>(operation: (SqliteTransaction) -> Promise<T>) -> T:
         const results: List<T> = []
-        async def run<T>(native: NativeSqliteTransaction):
-            results.append(await operation(SqliteTransaction(native)))
+        async def run<T>(native: NativeSqliteTransaction): results.append(await operation(SqliteTransaction(native)))
         try:
             await self.native.transaction(run)
             assert results.size == 1 else "SQLite transaction did not return exactly one result"
             return results[0]
         catch error:
-            if error is NativeSqliteError:
-                throw sqliteFailure(error)
+            if error is NativeSqliteError: throw sqliteFailure(error)
             throw error
 
     async def close():
-        try:
-            await self.native.close()
+        try: await self.native.close()
         catch error:
-            if error is NativeSqliteError:
-                throw sqliteFailure(error)
+            if error is NativeSqliteError: throw sqliteFailure(error)
             throw SqliteError(error.message)
 
-    @dispose:
-        await self.close()
+    @dispose: await self.close()
 
 export async def openSqlite(path: string, options: SqliteOptions = {}) -> SqliteConnection:
-    try:
-        return SqliteConnection(await openNativeSqlite(path, options))
+    try: return SqliteConnection(await openNativeSqlite(path, options))
     catch error:
-        if error is NativeSqliteError:
-            throw sqliteFailure(error)
+        if error is NativeSqliteError: throw sqliteFailure(error)
         throw SqliteError(error.message)