=> {
await client.batch([
"DROP TABLE IF EXISTS t",
"CREATE TABLE t (a, b)",
diff --git a/packages/libsql-client/smoke_test/vercel/app/public/index.html b/packages/libsql-client/smoke_test/vercel/app/public/index.html
index e3d18d45..bc129de7 100644
--- a/packages/libsql-client/smoke_test/vercel/app/public/index.html
+++ b/packages/libsql-client/smoke_test/vercel/app/public/index.html
@@ -1,3 +1,5 @@
-
-This is a smoke-test Vercel app for @libsql/client.
+
+ This is a smoke-test Vercel app for @libsql/client.
+
+
diff --git a/packages/libsql-client/smoke_test/vercel/test.js b/packages/libsql-client/smoke_test/vercel/test.js
index d6c22189..8cd1fbbd 100644
--- a/packages/libsql-client/smoke_test/vercel/test.js
+++ b/packages/libsql-client/smoke_test/vercel/test.js
@@ -15,8 +15,13 @@ function getEnv(name) {
const vercelToken = getEnv("VERCEL_TOKEN");
const projectName = getEnv("VERCEL_PROJECT_NAME");
-async function npm(subcommand, args, hiddenArgs = [], {capture = false} = {}) {
- console.info(`$ npm ${subcommand} ${args.join(' ')}`);
+async function npm(
+ subcommand,
+ args,
+ hiddenArgs = [],
+ { capture = false } = {},
+) {
+ console.info(`$ npm ${subcommand} ${args.join(" ")}`);
const proc = spawn("npm", [subcommand, ...args, ...hiddenArgs], {
stdio: ["ignore", capture ? "pipe" : "inherit", "inherit"],
@@ -25,7 +30,11 @@ async function npm(subcommand, args, hiddenArgs = [], {capture = false} = {}) {
const exitPromise = new Promise((resolve, reject) => {
proc.on("exit", (code, signal) => {
if (signal !== null) {
- reject(new Error(`vercel command terminated due to signal: ${signal}`));
+ reject(
+ new Error(
+ `vercel command terminated due to signal: ${signal}`,
+ ),
+ );
} else if (code !== 0) {
reject(new Error(`vercel command exited with code: ${code}`));
} else {
@@ -54,39 +63,62 @@ async function npm(subcommand, args, hiddenArgs = [], {capture = false} = {}) {
async function deployToVercel(clientUrlInsideVercel) {
console.info("Building and deploying to Vercel...");
- let tarballName = await npm("pack", ["../.."], [], {capture: true});
+ let tarballName = await npm("pack", ["../.."], [], { capture: true });
tarballName = tarballName.trim();
const appPackageJson = {
- "dependencies": {
+ dependencies: {
"@libsql/client": `../${tarballName}`,
},
};
- fs.writeFileSync("app/package.json", JSON.stringify(appPackageJson, null, 4));
+ fs.writeFileSync(
+ "app/package.json",
+ JSON.stringify(appPackageJson, null, 4),
+ );
await npm(
"exec",
- ["--", "vercel", "link", "--yes", "--project", projectName, "--cwd", "app/"],
+ [
+ "--",
+ "vercel",
+ "link",
+ "--yes",
+ "--project",
+ projectName,
+ "--cwd",
+ "app/",
+ ],
["--token", vercelToken],
);
await npm(
"exec",
- ["--", "vercel", "pull", "--yes", "--environment=preview", "--cwd", "app/"],
+ [
+ "--",
+ "vercel",
+ "pull",
+ "--yes",
+ "--environment=preview",
+ "--cwd",
+ "app/",
+ ],
["--token", vercelToken],
);
- await npm(
- "exec",
- ["--", "vercel", "build", "--cwd", "app/"],
- );
+ await npm("exec", ["--", "vercel", "build", "--cwd", "app/"]);
const deployUrl = await npm(
"exec",
[
- "--", "vercel", "deploy", "--prebuilt",
- "--env", `CLIENT_URL=${clientUrlInsideVercel}`, "--cwd", "app/",
+ "--",
+ "vercel",
+ "deploy",
+ "--prebuilt",
+ "--env",
+ `CLIENT_URL=${clientUrlInsideVercel}`,
+ "--cwd",
+ "app/",
],
["--token", vercelToken, "--cwd", "app/"],
- {capture: true},
+ { capture: true },
);
console.info(`Deployed Vercel project on ${deployUrl}`);
@@ -98,7 +130,7 @@ const testCases = ["execute", "batch", "transaction"];
async function runTests(functionUrl) {
let ok = true;
for (const testCase of testCases) {
- if (!await runTest(functionUrl, testCase)) {
+ if (!(await runTest(functionUrl, testCase))) {
ok = false;
}
}
@@ -112,7 +144,9 @@ async function runTest(functionUrl, testCase) {
if (ok) {
console.info(`TEST ${testCase}: passed`);
} else {
- console.warn(`\nTEST ${testCase}: failed with status ${resp.status}\n${respText}\n`);
+ console.warn(
+ `\nTEST ${testCase}: failed with status ${resp.status}\n${respText}\n`,
+ );
}
return ok;
}
diff --git a/packages/libsql-client/smoke_test/vercel/tsconfig.json b/packages/libsql-client/smoke_test/vercel/tsconfig.json
index 966e86fc..74ac41e2 100644
--- a/packages/libsql-client/smoke_test/vercel/tsconfig.json
+++ b/packages/libsql-client/smoke_test/vercel/tsconfig.json
@@ -1,14 +1,14 @@
{
- "compilerOptions": {
- "target": "es5",
- "lib": ["dom", "esnext"],
- "module": "esnext",
- "moduleResolution": "node",
- "allowJs": true,
- "skipLibCheck": true,
- "strict": true,
- "noEmit": true,
- "esModuleInterop": true,
- "isolatedModules": true
- }
+ "compilerOptions": {
+ "target": "es5",
+ "lib": ["dom", "esnext"],
+ "module": "esnext",
+ "moduleResolution": "node",
+ "allowJs": true,
+ "skipLibCheck": true,
+ "strict": true,
+ "noEmit": true,
+ "esModuleInterop": true,
+ "isolatedModules": true
+ }
}
diff --git a/packages/libsql-client/smoke_test/workers/test.js b/packages/libsql-client/smoke_test/workers/test.js
index 5d5d567a..8d776ebf 100644
--- a/packages/libsql-client/smoke_test/workers/test.js
+++ b/packages/libsql-client/smoke_test/workers/test.js
@@ -55,24 +55,24 @@ async function main() {
}
async function runWorker(local, clientUrlInsideWorker) {
- console.info(`Creating a ${local ? 'local' : 'nonlocal'} Worker...`);
+ console.info(`Creating a ${local ? "local" : "nonlocal"} Worker...`);
const worker = await wrangler.unstable_dev("worker.js", {
config: "wrangler.toml",
logLevel: "info",
local,
vars: {
- "CLIENT_URL": clientUrlInsideWorker.toString(),
+ CLIENT_URL: clientUrlInsideWorker.toString(),
},
experimental: {
disableExperimentalWarning: true,
- }
+ },
});
console.info(`Worker created on ${worker.address}:${worker.port}`);
try {
let ok = true;
for (const testCase of testCases) {
- if (!await runTest(worker, testCase)) {
+ if (!(await runTest(worker, testCase))) {
ok = false;
}
}
@@ -90,7 +90,9 @@ async function runTest(worker, testCase) {
if (ok) {
console.info(`TEST ${testCase}: passed`);
} else {
- console.warn(`\nTEST ${testCase}: failed with status ${resp.status}\n${respText}\n`);
+ console.warn(
+ `\nTEST ${testCase}: failed with status ${resp.status}\n${respText}\n`,
+ );
}
return ok;
}
diff --git a/packages/libsql-client/smoke_test/workers/worker.js b/packages/libsql-client/smoke_test/workers/worker.js
index 62a6492b..7af79718 100644
--- a/packages/libsql-client/smoke_test/workers/worker.js
+++ b/packages/libsql-client/smoke_test/workers/worker.js
@@ -5,9 +5,7 @@ export default {
function respond(status, responseBody) {
return new Response(responseBody, {
status,
- headers: [
- ["content-type", "text/plain"],
- ],
+ headers: [["content-type", "text/plain"]],
});
}
@@ -17,7 +15,10 @@ export default {
const url = new URL(request.url);
if (url.pathname === "/") {
- return respond(200, "This is a smoke-test Worker for @libsql/client");
+ return respond(
+ 200,
+ "This is a smoke-test Worker for @libsql/client",
+ );
}
const testCaseFn = testCases[url.pathname];
@@ -27,7 +28,7 @@ export default {
let client;
try {
- client = libsql.createClient({url: env.CLIENT_URL});
+ client = libsql.createClient({ url: env.CLIENT_URL });
await testCaseFn(client);
return respond(200, "Test passed");
} catch (e) {
diff --git a/packages/libsql-client/src/__tests__/client.test.ts b/packages/libsql-client/src/__tests__/client.test.ts
index 6ae29488..7d230e96 100644
--- a/packages/libsql-client/src/__tests__/client.test.ts
+++ b/packages/libsql-client/src/__tests__/client.test.ts
@@ -16,8 +16,12 @@ const config = {
authToken: process.env.AUTH_TOKEN,
};
-const isWs = config.url.startsWith("ws:") || config.url.startsWith("wss:") || config.url.startsWith("libsql:");
-const isHttp = config.url.startsWith("http:") || config.url.startsWith("https:");
+const isWs =
+ config.url.startsWith("ws:") ||
+ config.url.startsWith("wss:") ||
+ config.url.startsWith("libsql:");
+const isHttp =
+ config.url.startsWith("http:") || config.url.startsWith("https:");
const isFile = config.url.startsWith("file:");
// This allows us to skip tests based on the Hrana server that we are targeting:
@@ -29,14 +33,16 @@ const server = process.env.SERVER ?? "test_v3";
const hasHrana2 = server !== "test_v1";
const hasHrana3 = server !== "test_v1" && server !== "test_v2";
-const hasNetworkErrors = isWs && (server === "test_v1" || server === "test_v2" || server === "test_v3");
+const hasNetworkErrors =
+ isWs &&
+ (server === "test_v1" || server === "test_v2" || server === "test_v3");
function withClient(
f: (c: libsql.Client) => Promise,
extraConfig: Partial = {},
): () => Promise {
return async () => {
- const c = createClient({...config, ...extraConfig});
+ const c = createClient({ ...config, ...extraConfig });
try {
await f(c);
} finally {
@@ -60,13 +66,15 @@ function withInMemoryClient(
describe("createClient()", () => {
test("URL scheme not supported", () => {
- expect(() => createClient({url: "ftp://localhost"}))
- .toThrow(expect.toBeLibsqlError("URL_SCHEME_NOT_SUPPORTED", /"ftp:"/));
+ expect(() => createClient({ url: "ftp://localhost" })).toThrow(
+ expect.toBeLibsqlError("URL_SCHEME_NOT_SUPPORTED", /"ftp:"/),
+ );
});
test("URL param not supported", () => {
- expect(() => createClient({url: "ws://localhost?foo=bar"}))
- .toThrow(expect.toBeLibsqlError("URL_PARAM_NOT_SUPPORTED", /"foo"/));
+ expect(() => createClient({ url: "ws://localhost?foo=bar" })).toThrow(
+ expect.toBeLibsqlError("URL_PARAM_NOT_SUPPORTED", /"foo"/),
+ );
});
test("URL scheme incompatible with ?tls", () => {
@@ -77,148 +85,207 @@ describe("createClient()", () => {
"https://localhost?tls=0",
];
for (const url of urls) {
- expect(() => createClient({url}))
- .toThrow(expect.toBeLibsqlError("URL_INVALID", /TLS/));
+ expect(() => createClient({ url })).toThrow(
+ expect.toBeLibsqlError("URL_INVALID", /TLS/),
+ );
}
});
test("missing port in libsql URL with tls=0", () => {
- expect(() => createClient({url: "libsql://localhost?tls=0"}))
- .toThrow(expect.toBeLibsqlError("URL_INVALID", /port/));
+ expect(() => createClient({ url: "libsql://localhost?tls=0" })).toThrow(
+ expect.toBeLibsqlError("URL_INVALID", /port/),
+ );
});
test("invalid value of tls query param", () => {
- expect(() => createClient({url: "libsql://localhost?tls=yes"}))
- .toThrow(expect.toBeLibsqlError("URL_INVALID", /"tls".*"yes"/));
+ expect(() =>
+ createClient({ url: "libsql://localhost?tls=yes" }),
+ ).toThrow(expect.toBeLibsqlError("URL_INVALID", /"tls".*"yes"/));
});
test("passing URL instead of config object", () => {
// @ts-expect-error
- expect(() => createClient("ws://localhost")).toThrow(/as object, got string/);
+ expect(() => createClient("ws://localhost")).toThrow(
+ /as object, got string/,
+ );
});
test("invalid value for `intMode`", () => {
// @ts-expect-error
- expect(() => createClient({...config, intMode: "foo"})).toThrow(/"foo"/);
+ expect(() => createClient({ ...config, intMode: "foo" })).toThrow(
+ /"foo"/,
+ );
});
test("supports in-memory database", () => {
- expect(() => createClient({url: ":memory:"})).not.toThrow();
+ expect(() => createClient({ url: ":memory:" })).not.toThrow();
});
});
describe("execute()", () => {
- test("query a single value", withClient(async (c) => {
- const rs = await c.execute("SELECT 42");
- expect(rs.columns.length).toStrictEqual(1);
- expect(rs.columnTypes.length).toStrictEqual(1);
- expect(rs.rows.length).toStrictEqual(1);
- expect(rs.rows[0].length).toStrictEqual(1);
- expect(rs.rows[0][0]).toStrictEqual(42);
- }));
-
- test("query a single row", withClient(async (c) => {
- const rs = await c.execute("SELECT 1 AS one, 'two' AS two, 0.5 AS three");
- expect(rs.columns).toStrictEqual(["one", "two", "three"]);
- expect(rs.columnTypes).toStrictEqual(["", "", ""]);
- expect(rs.rows.length).toStrictEqual(1);
-
- const r = rs.rows[0];
- expect(r.length).toStrictEqual(3);
- expect(Array.from(r)).toStrictEqual([1, "two", 0.5]);
- expect(Object.entries(r)).toStrictEqual([["one", 1], ["two", "two"], ["three", 0.5]]);
- }));
-
- test("query multiple rows", withClient(async (c) => {
- const rs = await c.execute("VALUES (1, 'one'), (2, 'two'), (3, 'three')");
- expect(rs.columns.length).toStrictEqual(2);
- expect(rs.columnTypes.length).toStrictEqual(2);
- expect(rs.rows.length).toStrictEqual(3);
-
- expect(Array.from(rs.rows[0])).toStrictEqual([1, "one"]);
- expect(Array.from(rs.rows[1])).toStrictEqual([2, "two"]);
- expect(Array.from(rs.rows[2])).toStrictEqual([3, "three"]);
- }));
-
- test("statement that produces error", withClient(async (c) => {
- await expect(c.execute("SELECT foobar")).rejects.toBeLibsqlError();
- }));
-
- test("rowsAffected with INSERT", withClient(async (c) => {
- await c.batch([
- "DROP TABLE IF EXISTS t",
- "CREATE TABLE t (a)",
- ], "write");
- const rs = await c.execute("INSERT INTO t VALUES (1), (2)");
- expect(rs.rowsAffected).toStrictEqual(2);
- }));
-
- test("rowsAffected with DELETE", withClient(async (c) => {
- await c.batch([
- "DROP TABLE IF EXISTS t",
- "CREATE TABLE t (a)",
- "INSERT INTO t VALUES (1), (2), (3), (4), (5)",
- ], "write");
- const rs = await c.execute("DELETE FROM t WHERE a >= 3");
- expect(rs.rowsAffected).toStrictEqual(3);
- }));
-
- test("lastInsertRowid with INSERT", withClient(async (c) => {
- await c.batch([
- "DROP TABLE IF EXISTS t",
- "CREATE TABLE t (a)",
- "INSERT INTO t VALUES ('one'), ('two')",
- ], "write");
- const insertRs = await c.execute("INSERT INTO t VALUES ('three')");
- expect(insertRs.lastInsertRowid).not.toBeUndefined();
- const selectRs = await c.execute({
- sql: "SELECT a FROM t WHERE ROWID = ?",
- args: [insertRs.lastInsertRowid!],
- });
- expect(Array.from(selectRs.rows[0])).toStrictEqual(["three"]);
- }));
-
- test("rows from INSERT RETURNING", withClient(async (c) => {
- await c.batch([
- "DROP TABLE IF EXISTS t",
- "CREATE TABLE t (a)",
- ], "write");
-
- const rs = await c.execute("INSERT INTO t VALUES (1) RETURNING 42 AS x, 'foo' AS y");
- expect(rs.columns).toStrictEqual(["x", "y"]);
- expect(rs.columnTypes).toStrictEqual(["", ""]);
- expect(rs.rows.length).toStrictEqual(1);
- expect(Array.from(rs.rows[0])).toStrictEqual([42, "foo"]);
- }));
-
- (hasHrana2 ? test : test.skip)("rowsAffected with WITH INSERT", withClient(async (c) => {
- await c.batch([
- "DROP TABLE IF EXISTS t",
- "CREATE TABLE t (a)",
- "INSERT INTO t VALUES (1), (2), (3)",
- ], "write");
-
- const rs = await c.execute(`
+ test(
+ "query a single value",
+ withClient(async (c) => {
+ const rs = await c.execute("SELECT 42");
+ expect(rs.columns.length).toStrictEqual(1);
+ expect(rs.columnTypes.length).toStrictEqual(1);
+ expect(rs.rows.length).toStrictEqual(1);
+ expect(rs.rows[0].length).toStrictEqual(1);
+ expect(rs.rows[0][0]).toStrictEqual(42);
+ }),
+ );
+
+ test(
+ "query a single row",
+ withClient(async (c) => {
+ const rs = await c.execute(
+ "SELECT 1 AS one, 'two' AS two, 0.5 AS three",
+ );
+ expect(rs.columns).toStrictEqual(["one", "two", "three"]);
+ expect(rs.columnTypes).toStrictEqual(["", "", ""]);
+ expect(rs.rows.length).toStrictEqual(1);
+
+ const r = rs.rows[0];
+ expect(r.length).toStrictEqual(3);
+ expect(Array.from(r)).toStrictEqual([1, "two", 0.5]);
+ expect(Object.entries(r)).toStrictEqual([
+ ["one", 1],
+ ["two", "two"],
+ ["three", 0.5],
+ ]);
+ }),
+ );
+
+ test(
+ "query multiple rows",
+ withClient(async (c) => {
+ const rs = await c.execute(
+ "VALUES (1, 'one'), (2, 'two'), (3, 'three')",
+ );
+ expect(rs.columns.length).toStrictEqual(2);
+ expect(rs.columnTypes.length).toStrictEqual(2);
+ expect(rs.rows.length).toStrictEqual(3);
+
+ expect(Array.from(rs.rows[0])).toStrictEqual([1, "one"]);
+ expect(Array.from(rs.rows[1])).toStrictEqual([2, "two"]);
+ expect(Array.from(rs.rows[2])).toStrictEqual([3, "three"]);
+ }),
+ );
+
+ test(
+ "statement that produces error",
+ withClient(async (c) => {
+ await expect(c.execute("SELECT foobar")).rejects.toBeLibsqlError();
+ }),
+ );
+
+ test(
+ "rowsAffected with INSERT",
+ withClient(async (c) => {
+ await c.batch(
+ ["DROP TABLE IF EXISTS t", "CREATE TABLE t (a)"],
+ "write",
+ );
+ const rs = await c.execute("INSERT INTO t VALUES (1), (2)");
+ expect(rs.rowsAffected).toStrictEqual(2);
+ }),
+ );
+
+ test(
+ "rowsAffected with DELETE",
+ withClient(async (c) => {
+ await c.batch(
+ [
+ "DROP TABLE IF EXISTS t",
+ "CREATE TABLE t (a)",
+ "INSERT INTO t VALUES (1), (2), (3), (4), (5)",
+ ],
+ "write",
+ );
+ const rs = await c.execute("DELETE FROM t WHERE a >= 3");
+ expect(rs.rowsAffected).toStrictEqual(3);
+ }),
+ );
+
+ test(
+ "lastInsertRowid with INSERT",
+ withClient(async (c) => {
+ await c.batch(
+ [
+ "DROP TABLE IF EXISTS t",
+ "CREATE TABLE t (a)",
+ "INSERT INTO t VALUES ('one'), ('two')",
+ ],
+ "write",
+ );
+ const insertRs = await c.execute("INSERT INTO t VALUES ('three')");
+ expect(insertRs.lastInsertRowid).not.toBeUndefined();
+ const selectRs = await c.execute({
+ sql: "SELECT a FROM t WHERE ROWID = ?",
+ args: [insertRs.lastInsertRowid!],
+ });
+ expect(Array.from(selectRs.rows[0])).toStrictEqual(["three"]);
+ }),
+ );
+
+ test(
+ "rows from INSERT RETURNING",
+ withClient(async (c) => {
+ await c.batch(
+ ["DROP TABLE IF EXISTS t", "CREATE TABLE t (a)"],
+ "write",
+ );
+
+ const rs = await c.execute(
+ "INSERT INTO t VALUES (1) RETURNING 42 AS x, 'foo' AS y",
+ );
+ expect(rs.columns).toStrictEqual(["x", "y"]);
+ expect(rs.columnTypes).toStrictEqual(["", ""]);
+ expect(rs.rows.length).toStrictEqual(1);
+ expect(Array.from(rs.rows[0])).toStrictEqual([42, "foo"]);
+ }),
+ );
+
+ (hasHrana2 ? test : test.skip)(
+ "rowsAffected with WITH INSERT",
+ withClient(async (c) => {
+ await c.batch(
+ [
+ "DROP TABLE IF EXISTS t",
+ "CREATE TABLE t (a)",
+ "INSERT INTO t VALUES (1), (2), (3)",
+ ],
+ "write",
+ );
+
+ const rs = await c.execute(`
WITH x(a) AS (SELECT 2*a FROM t)
INSERT INTO t SELECT a+1 FROM x
`);
- expect(rs.rowsAffected).toStrictEqual(3);
- }));
-
- test("query a single value using an in memory database", withInMemoryClient(async (c) => {
- await c.batch([
- "DROP TABLE IF EXISTS t",
- "CREATE TABLE t (a)",
- "INSERT INTO t VALUES ('one'), ('two')",
- ], "write");
- const insertRs = await c.execute("INSERT INTO t VALUES ('three')");
- expect(insertRs.lastInsertRowid).not.toBeUndefined();
- const selectRs = await c.execute({
- sql: "SELECT a FROM t WHERE ROWID = ?",
- args: [insertRs.lastInsertRowid!],
- });
- expect(Array.from(selectRs.rows[0])).toStrictEqual(["three"]);
- }));
+ expect(rs.rowsAffected).toStrictEqual(3);
+ }),
+ );
+
+ test(
+ "query a single value using an in memory database",
+ withInMemoryClient(async (c) => {
+ await c.batch(
+ [
+ "DROP TABLE IF EXISTS t",
+ "CREATE TABLE t (a)",
+ "INSERT INTO t VALUES ('one'), ('two')",
+ ],
+ "write",
+ );
+ const insertRs = await c.execute("INSERT INTO t VALUES ('three')");
+ expect(insertRs.lastInsertRowid).not.toBeUndefined();
+ const selectRs = await c.execute({
+ sql: "SELECT a FROM t WHERE ROWID = ?",
+ args: [insertRs.lastInsertRowid!],
+ });
+ expect(Array.from(selectRs.rows[0])).toStrictEqual(["three"]);
+ }),
+ );
});
describe("values", () => {
@@ -228,10 +295,19 @@ describe("values", () => {
expected: libsql.Value,
intMode?: libsql.IntMode,
): void {
- test(name, withClient(async (c) => {
- const rs = await c.execute({sql: "SELECT ?", args: [passed]});
- expect(rs.rows[0][0]).toStrictEqual(expected);
- }, {intMode}));
+ test(
+ name,
+ withClient(
+ async (c) => {
+ const rs = await c.execute({
+ sql: "SELECT ?",
+ args: [passed],
+ });
+ expect(rs.rows[0][0]).toStrictEqual(expected);
+ },
+ { intMode },
+ ),
+ );
}
function testRoundtripError(
@@ -240,18 +316,29 @@ describe("values", () => {
expectedError: unknown,
intMode?: libsql.IntMode,
): void {
- test(name, withClient(async (c) => {
- await expect(c.execute({
- sql: "SELECT ?",
- args: [passed],
- })).rejects.toBeInstanceOf(expectedError);
- }, {intMode}));
+ test(
+ name,
+ withClient(
+ async (c) => {
+ await expect(
+ c.execute({
+ sql: "SELECT ?",
+ args: [passed],
+ }),
+ ).rejects.toBeInstanceOf(expectedError);
+ },
+ { intMode },
+ ),
+ );
}
testRoundtrip("string", "boomerang", "boomerang");
testRoundtrip("string with weird characters", "a\n\r\t ", "a\n\r\t ");
- testRoundtrip("string with unicode",
- "žluťoučký kůň úpěl ďábelské ódy", "žluťoučký kůň úpěl ďábelské ódy");
+ testRoundtrip(
+ "string with unicode",
+ "žluťoučký kůň úpěl ďábelské ódy",
+ "žluťoučký kůň úpěl ďábelské ódy",
+ );
describe("number", () => {
const intModes: Array = ["number", "bigint", "string"];
@@ -261,9 +348,24 @@ describe("values", () => {
testRoundtrip("float", 12.345, 12.345, intMode);
testRoundtrip("large positive float", 1e18, 1e18, intMode);
testRoundtrip("large negative float", -1e18, -1e18, intMode);
- testRoundtrip("MAX_VALUE", Number.MAX_VALUE, Number.MAX_VALUE, intMode);
- testRoundtrip("-MAX_VALUE", -Number.MAX_VALUE, -Number.MAX_VALUE, intMode);
- testRoundtrip("MIN_VALUE", Number.MIN_VALUE, Number.MIN_VALUE, intMode);
+ testRoundtrip(
+ "MAX_VALUE",
+ Number.MAX_VALUE,
+ Number.MAX_VALUE,
+ intMode,
+ );
+ testRoundtrip(
+ "-MAX_VALUE",
+ -Number.MAX_VALUE,
+ -Number.MAX_VALUE,
+ intMode,
+ );
+ testRoundtrip(
+ "MIN_VALUE",
+ Number.MIN_VALUE,
+ Number.MIN_VALUE,
+ intMode,
+ );
}
});
@@ -271,27 +373,82 @@ describe("values", () => {
describe("'number' int mode", () => {
testRoundtrip("zero integer", 0n, 0, "number");
testRoundtrip("small integer", -42n, -42, "number");
- testRoundtrip("largest safe integer", 9007199254740991n, 9007199254740991, "number");
- testRoundtripError("smallest unsafe integer", 9007199254740992n, RangeError, "number");
- testRoundtripError("large unsafe integer", -1152921504594532842n, RangeError, "number");
+ testRoundtrip(
+ "largest safe integer",
+ 9007199254740991n,
+ 9007199254740991,
+ "number",
+ );
+ testRoundtripError(
+ "smallest unsafe integer",
+ 9007199254740992n,
+ RangeError,
+ "number",
+ );
+ testRoundtripError(
+ "large unsafe integer",
+ -1152921504594532842n,
+ RangeError,
+ "number",
+ );
});
describe("'bigint' int mode", () => {
testRoundtrip("zero integer", 0n, 0n, "bigint");
testRoundtrip("small integer", -42n, -42n, "bigint");
- testRoundtrip("large positive integer", 1152921504608088318n, 1152921504608088318n, "bigint");
- testRoundtrip("large negative integer", -1152921504594532842n, -1152921504594532842n, "bigint");
- testRoundtrip("largest positive integer", 9223372036854775807n, 9223372036854775807n, "bigint");
- testRoundtrip("largest negative integer", -9223372036854775808n, -9223372036854775808n, "bigint");
+ testRoundtrip(
+ "large positive integer",
+ 1152921504608088318n,
+ 1152921504608088318n,
+ "bigint",
+ );
+ testRoundtrip(
+ "large negative integer",
+ -1152921504594532842n,
+ -1152921504594532842n,
+ "bigint",
+ );
+ testRoundtrip(
+ "largest positive integer",
+ 9223372036854775807n,
+ 9223372036854775807n,
+ "bigint",
+ );
+ testRoundtrip(
+ "largest negative integer",
+ -9223372036854775808n,
+ -9223372036854775808n,
+ "bigint",
+ );
});
describe("'string' int mode", () => {
testRoundtrip("zero integer", 0n, "0", "string");
testRoundtrip("small integer", -42n, "-42", "string");
- testRoundtrip("large positive integer", 1152921504608088318n, "1152921504608088318", "string");
- testRoundtrip("large negative integer", -1152921504594532842n, "-1152921504594532842", "string");
- testRoundtrip("largest positive integer", 9223372036854775807n, "9223372036854775807", "string");
- testRoundtrip("largest negative integer", -9223372036854775808n, "-9223372036854775808", "string");
+ testRoundtrip(
+ "large positive integer",
+ 1152921504608088318n,
+ "1152921504608088318",
+ "string",
+ );
+ testRoundtrip(
+ "large negative integer",
+ -1152921504594532842n,
+ "-1152921504594532842",
+ "string",
+ );
+ testRoundtrip(
+ "largest positive integer",
+ 9223372036854775807n,
+ "9223372036854775807",
+ "string",
+ );
+ testRoundtrip(
+ "largest negative integer",
+ -9223372036854775808n,
+ "-9223372036854775808",
+ "string",
+ );
});
});
@@ -312,597 +469,810 @@ describe("values", () => {
testRoundtrip("false", false, "0", "string");
testRoundtrip("true", true, 1);
testRoundtrip("false", false, 0);
-
- testRoundtrip("Date", new Date("2023-01-02T12:34:56Z"), 1672662896000, "bigint");
+
+ testRoundtrip(
+ "Date",
+ new Date("2023-01-02T12:34:56Z"),
+ 1672662896000,
+ "bigint",
+ );
// @ts-expect-error
testRoundtripError("undefined produces error", undefined, TypeError);
testRoundtripError("NaN produces error", NaN, RangeError);
testRoundtripError("Infinity produces error", Infinity, RangeError);
- testRoundtripError("large bigint produces error", -1267650600228229401496703205376n, RangeError);
-
- test("max 64-bit bigint", withClient(async (c) => {
- const rs = await c.execute({sql: "SELECT ?||''", args: [9223372036854775807n]});
- expect(rs.rows[0][0]).toStrictEqual("9223372036854775807");
- }));
+ testRoundtripError(
+ "large bigint produces error",
+ -1267650600228229401496703205376n,
+ RangeError,
+ );
+
+ test(
+ "max 64-bit bigint",
+ withClient(async (c) => {
+ const rs = await c.execute({
+ sql: "SELECT ?||''",
+ args: [9223372036854775807n],
+ });
+ expect(rs.rows[0][0]).toStrictEqual("9223372036854775807");
+ }),
+ );
- test("min 64-bit bigint", withClient(async (c) => {
- const rs = await c.execute({sql: "SELECT ?||''", args: [-9223372036854775808n]});
- expect(rs.rows[0][0]).toStrictEqual("-9223372036854775808");
- }));
+ test(
+ "min 64-bit bigint",
+ withClient(async (c) => {
+ const rs = await c.execute({
+ sql: "SELECT ?||''",
+ args: [-9223372036854775808n],
+ });
+ expect(rs.rows[0][0]).toStrictEqual("-9223372036854775808");
+ }),
+ );
});
describe("ResultSet.toJSON()", () => {
- test("simple result set", withClient(async (c) => {
- const rs = await c.execute("SELECT 1 AS a");
- const json = rs.toJSON();
- expect(json["lastInsertRowid"] === null || json["lastInsertRowid"] === "0").toBe(true);
- expect(json["columns"]).toStrictEqual(["a"]);
- expect(json["columnTypes"]).toStrictEqual([""]);
- expect(json["rows"]).toStrictEqual([[1]]);
- expect(json["rowsAffected"]).toStrictEqual(0);
-
- const str = JSON.stringify(rs);
- expect(
- str === '{"columns":["a"],"columnTypes":[""],"rows":[[1]],"rowsAffected":0,"lastInsertRowid":null}' ||
- str === '{"columns":["a"],"columnTypes":[""],"rows":[[1]],"rowsAffected":0,"lastInsertRowid":"0"}'
- ).toBe(true);
- }));
-
- test("lastInsertRowid", withClient(async (c) => {
- await c.execute("DROP TABLE IF EXISTS t");
- await c.execute("CREATE TABLE t (id INTEGER PRIMARY KEY NOT NULL)");
- const rs = await c.execute("INSERT INTO t VALUES (12345)");
- expect(rs.toJSON()).toStrictEqual({
- "columns": [],
- "columnTypes": [],
- "rows": [],
- "rowsAffected": 1,
- "lastInsertRowid": "12345",
- });
- }));
-
- test("computed values", withClient(async (c) => {
- const rs = await c.execute(
- "SELECT 42 AS integer, 0.5 AS float, NULL AS \"null\", 'foo' AS text, X'626172' AS blob",
- );
- const json = rs.toJSON();
- expect(json["columns"]).toStrictEqual(["integer", "float", "null", "text", "blob"]);
- expect(json["columnTypes"]).toStrictEqual(["", "", "", "", ""]);
- expect(json["rows"]).toStrictEqual([[42, 0.5, null, "foo", "YmFy"]]);
- }));
-
- (hasHrana2 ? test : test.skip)("row values", withClient(async (c) => {
- await c.execute("DROP TABLE IF EXISTS t");
- await c.execute("CREATE TABLE t (i INTEGER, f FLOAT, t TEXT, b BLOB)");
- await c.execute("INSERT INTO t VALUES (42, 0.5, 'foo', X'626172')");
- const rs = await c.execute(
- "SELECT i, f, t, b FROM t LIMIT 1",
- );
- const json = rs.toJSON();
- expect(json["columns"]).toStrictEqual(["i", "f", "t", "b"]);
- expect(json["columnTypes"]).toStrictEqual(["INTEGER", "FLOAT", "TEXT", "BLOB"]);
- expect(json["rows"]).toStrictEqual([[42, 0.5, "foo", "YmFy"]]);
- }));
-
- test("bigint row value", withClient(async (c) => {
- const rs = await c.execute("SELECT 42");
- const json = rs.toJSON();
- expect(json["rows"]).toStrictEqual([["42"]]);
- }, {intMode: "bigint"}));
+ test(
+ "simple result set",
+ withClient(async (c) => {
+ const rs = await c.execute("SELECT 1 AS a");
+ const json = rs.toJSON();
+ expect(
+ json["lastInsertRowid"] === null ||
+ json["lastInsertRowid"] === "0",
+ ).toBe(true);
+ expect(json["columns"]).toStrictEqual(["a"]);
+ expect(json["columnTypes"]).toStrictEqual([""]);
+ expect(json["rows"]).toStrictEqual([[1]]);
+ expect(json["rowsAffected"]).toStrictEqual(0);
+
+ const str = JSON.stringify(rs);
+ expect(
+ str ===
+ '{"columns":["a"],"columnTypes":[""],"rows":[[1]],"rowsAffected":0,"lastInsertRowid":null}' ||
+ str ===
+ '{"columns":["a"],"columnTypes":[""],"rows":[[1]],"rowsAffected":0,"lastInsertRowid":"0"}',
+ ).toBe(true);
+ }),
+ );
+
+ test(
+ "lastInsertRowid",
+ withClient(async (c) => {
+ await c.execute("DROP TABLE IF EXISTS t");
+ await c.execute("CREATE TABLE t (id INTEGER PRIMARY KEY NOT NULL)");
+ const rs = await c.execute("INSERT INTO t VALUES (12345)");
+ expect(rs.toJSON()).toStrictEqual({
+ columns: [],
+ columnTypes: [],
+ rows: [],
+ rowsAffected: 1,
+ lastInsertRowid: "12345",
+ });
+ }),
+ );
+
+ test(
+ "computed values",
+ withClient(async (c) => {
+ const rs = await c.execute(
+ "SELECT 42 AS integer, 0.5 AS float, NULL AS \"null\", 'foo' AS text, X'626172' AS blob",
+ );
+ const json = rs.toJSON();
+ expect(json["columns"]).toStrictEqual([
+ "integer",
+ "float",
+ "null",
+ "text",
+ "blob",
+ ]);
+ expect(json["columnTypes"]).toStrictEqual(["", "", "", "", ""]);
+ expect(json["rows"]).toStrictEqual([
+ [42, 0.5, null, "foo", "YmFy"],
+ ]);
+ }),
+ );
+
+ (hasHrana2 ? test : test.skip)(
+ "row values",
+ withClient(async (c) => {
+ await c.execute("DROP TABLE IF EXISTS t");
+ await c.execute(
+ "CREATE TABLE t (i INTEGER, f FLOAT, t TEXT, b BLOB)",
+ );
+ await c.execute("INSERT INTO t VALUES (42, 0.5, 'foo', X'626172')");
+ const rs = await c.execute("SELECT i, f, t, b FROM t LIMIT 1");
+ const json = rs.toJSON();
+ expect(json["columns"]).toStrictEqual(["i", "f", "t", "b"]);
+ expect(json["columnTypes"]).toStrictEqual([
+ "INTEGER",
+ "FLOAT",
+ "TEXT",
+ "BLOB",
+ ]);
+ expect(json["rows"]).toStrictEqual([[42, 0.5, "foo", "YmFy"]]);
+ }),
+ );
+
+ test(
+ "bigint row value",
+ withClient(
+ async (c) => {
+ const rs = await c.execute("SELECT 42");
+ const json = rs.toJSON();
+ expect(json["rows"]).toStrictEqual([["42"]]);
+ },
+ { intMode: "bigint" },
+ ),
+ );
});
describe("arguments", () => {
- test("? arguments", withClient(async (c) => {
- const rs = await c.execute({
- sql: "SELECT ?, ?",
- args: ["one", "two"],
- });
- expect(Array.from(rs.rows[0])).toStrictEqual(["one", "two"]);
- }));
-
- (!isFile ? test : test.skip)("?NNN arguments", withClient(async (c) => {
- const rs = await c.execute({
- sql: "SELECT ?2, ?3, ?1",
- args: ["one", "two", "three"],
- });
- expect(Array.from(rs.rows[0])).toStrictEqual(["two", "three", "one"]);
- }));
-
- (!isFile ? test : test.skip)("?NNN arguments with holes", withClient(async (c) => {
- const rs = await c.execute({
- sql: "SELECT ?3, ?1",
- args: ["one", "two", "three"],
- });
- expect(Array.from(rs.rows[0])).toStrictEqual(["three", "one"]);
- }));
-
- (!isFile ? test : test.skip)("?NNN and ? arguments", withClient(async (c) => {
- const rs = await c.execute({
- sql: "SELECT ?2, ?, ?3",
- args: ["one", "two", "three"],
- });
- expect(Array.from(rs.rows[0])).toStrictEqual(["two", "three", "three"]);
- }));
+ test(
+ "? arguments",
+ withClient(async (c) => {
+ const rs = await c.execute({
+ sql: "SELECT ?, ?",
+ args: ["one", "two"],
+ });
+ expect(Array.from(rs.rows[0])).toStrictEqual(["one", "two"]);
+ }),
+ );
- for (const sign of [":", "@", "$"]) {
- test(`${sign}AAAA arguments`, withClient(async (c) => {
+ (!isFile ? test : test.skip)(
+ "?NNN arguments",
+ withClient(async (c) => {
const rs = await c.execute({
- sql: `SELECT ${sign}b, ${sign}a`,
- args: {"a": "one", [`${sign}b`]: "two"},
+ sql: "SELECT ?2, ?3, ?1",
+ args: ["one", "two", "three"],
});
- expect(Array.from(rs.rows[0])).toStrictEqual(["two", "one"]);
- }));
+ expect(Array.from(rs.rows[0])).toStrictEqual([
+ "two",
+ "three",
+ "one",
+ ]);
+ }),
+ );
- test(`${sign}AAAA arguments used multiple times`, withClient(async (c) => {
+ (!isFile ? test : test.skip)(
+ "?NNN arguments with holes",
+ withClient(async (c) => {
const rs = await c.execute({
- sql: `SELECT ${sign}b, ${sign}a, ${sign}b || ${sign}a`,
- args: {"a": "one", [`${sign}b`]: "two"},
+ sql: "SELECT ?3, ?1",
+ args: ["one", "two", "three"],
});
- expect(Array.from(rs.rows[0])).toStrictEqual(["two", "one", "twoone"]);
- }));
+ expect(Array.from(rs.rows[0])).toStrictEqual(["three", "one"]);
+ }),
+ );
- test(`${sign}AAAA arguments and ?NNN arguments`, withClient(async (c) => {
+ (!isFile ? test : test.skip)(
+ "?NNN and ? arguments",
+ withClient(async (c) => {
const rs = await c.execute({
- sql: `SELECT ${sign}b, ${sign}a, ?1`,
- args: {"a": "one", [`${sign}b`]: "two"},
+ sql: "SELECT ?2, ?, ?3",
+ args: ["one", "two", "three"],
});
- expect(Array.from(rs.rows[0])).toStrictEqual(["two", "one", "two"]);
- }));
+ expect(Array.from(rs.rows[0])).toStrictEqual([
+ "two",
+ "three",
+ "three",
+ ]);
+ }),
+ );
+
+ for (const sign of [":", "@", "$"]) {
+ test(
+ `${sign}AAAA arguments`,
+ withClient(async (c) => {
+ const rs = await c.execute({
+ sql: `SELECT ${sign}b, ${sign}a`,
+ args: { a: "one", [`${sign}b`]: "two" },
+ });
+ expect(Array.from(rs.rows[0])).toStrictEqual(["two", "one"]);
+ }),
+ );
+
+ test(
+ `${sign}AAAA arguments used multiple times`,
+ withClient(async (c) => {
+ const rs = await c.execute({
+ sql: `SELECT ${sign}b, ${sign}a, ${sign}b || ${sign}a`,
+ args: { a: "one", [`${sign}b`]: "two" },
+ });
+ expect(Array.from(rs.rows[0])).toStrictEqual([
+ "two",
+ "one",
+ "twoone",
+ ]);
+ }),
+ );
+
+ test(
+ `${sign}AAAA arguments and ?NNN arguments`,
+ withClient(async (c) => {
+ const rs = await c.execute({
+ sql: `SELECT ${sign}b, ${sign}a, ?1`,
+ args: { a: "one", [`${sign}b`]: "two" },
+ });
+ expect(Array.from(rs.rows[0])).toStrictEqual([
+ "two",
+ "one",
+ "two",
+ ]);
+ }),
+ );
}
});
describe("batch()", () => {
- test("multiple queries", withClient(async (c) => {
- const rss = await c.batch([
- "SELECT 1+1",
- "SELECT 1 AS one, 2 AS two",
- {sql: "SELECT ?", args: ["boomerang"]},
- {sql: "VALUES (?), (?)", args: ["big", "ben"]},
- ], "read");
-
- expect(rss.length).toStrictEqual(4);
- const [rs0, rs1, rs2, rs3] = rss;
-
- expect(rs0.rows.length).toStrictEqual(1);
- expect(Array.from(rs0.rows[0])).toStrictEqual([2]);
-
- expect(rs1.rows.length).toStrictEqual(1);
- expect(Array.from(rs1.rows[0])).toStrictEqual([1, 2]);
-
- expect(rs2.rows.length).toStrictEqual(1);
- expect(Array.from(rs2.rows[0])).toStrictEqual(["boomerang"]);
-
- expect(rs3.rows.length).toStrictEqual(2);
- expect(Array.from(rs3.rows[0])).toStrictEqual(["big"]);
- expect(Array.from(rs3.rows[1])).toStrictEqual(["ben"]);
- }));
-
- test("statements are executed sequentially", withClient(async (c) => {
- const rss = await c.batch([
- /* 0 */ "DROP TABLE IF EXISTS t",
- /* 1 */ "CREATE TABLE t (a, b)",
- /* 2 */ "INSERT INTO t VALUES (1, 'one')",
- /* 3 */ "SELECT * FROM t ORDER BY a",
- /* 4 */ "INSERT INTO t VALUES (2, 'two')",
- /* 5 */ "SELECT * FROM t ORDER BY a",
- /* 6 */ "DROP TABLE t",
- ], "write");
-
- expect(rss.length).toStrictEqual(7);
- expect(rss[3].rows).toEqual([
- {a: 1, b: "one"},
- ]);
- expect(rss[5].rows).toEqual([
- {a: 1, b: "one"},
- {a: 2, b: "two"},
- ]);
- }));
-
- test("statements are executed in a transaction", withClient(async (c) => {
- await c.batch([
- "DROP TABLE IF EXISTS t1",
- "DROP TABLE IF EXISTS t2",
- "CREATE TABLE t1 (a)",
- "CREATE TABLE t2 (a)",
- ], "write");
-
- const n = 100;
- const promises = [];
- for (let i = 0; i < n; ++i) {
- const ii = i;
- promises.push((async () => {
- const rss = await c.batch([
- {sql: "INSERT INTO t1 VALUES (?)", args: [ii]},
- {sql: "INSERT INTO t2 VALUES (?)", args: [ii * 10]},
- "SELECT SUM(a) FROM t1",
- "SELECT SUM(a) FROM t2",
- ], "write");
-
- const sum1 = rss[2].rows[0][0] as number;
- const sum2 = rss[3].rows[0][0] as number;
- expect(sum2).toStrictEqual(sum1 * 10);
- })());
- }
- await Promise.all(promises);
-
- const rs1 = await c.execute("SELECT SUM(a) FROM t1");
- expect(rs1.rows[0][0]).toStrictEqual(n*(n-1)/2);
- const rs2 = await c.execute("SELECT SUM(a) FROM t2");
- expect(rs2.rows[0][0]).toStrictEqual(n*(n-1)/2*10);
- }), 10000);
-
- test("error in batch", withClient(async (c) => {
- await expect(c.batch([
- "SELECT 1+1",
- "SELECT foobar",
- ], "read")).rejects.toBeLibsqlError();
- }));
-
- test("error in batch rolls back transaction", withClient(async (c) => {
- await c.execute("DROP TABLE IF EXISTS t");
- await c.execute("CREATE TABLE t (a)");
- await c.execute("INSERT INTO t VALUES ('one')");
- await expect(c.batch([
- "INSERT INTO t VALUES ('two')",
- "SELECT foobar",
- "INSERT INTO t VALUES ('three')",
- ], "write")).rejects.toBeLibsqlError();
-
- const rs = await c.execute("SELECT COUNT(*) FROM t");
- expect(rs.rows[0][0]).toStrictEqual(1);
- }));
-
- test("batch with a lot of different statements", withClient(async (c) => {
- const stmts = [];
- for (let i = 0; i < 1000; ++i) {
- stmts.push(`SELECT ${i}`);
- }
- const rss = await c.batch(stmts, "read");
- for (let i = 0; i < stmts.length; ++i) {
- expect(rss[i].rows[0][0]).toStrictEqual(i);
- }
- }));
-
- test("batch with a lot of the same statements", withClient(async (c) => {
- const n = 20;
- const m = 200;
-
- const stmts = [];
- for (let i = 0; i < n; ++i) {
- for (let j = 0; j < m; ++j) {
- stmts.push({sql: `SELECT ?, ${j}`, args: [i]});
+ test(
+ "multiple queries",
+ withClient(async (c) => {
+ const rss = await c.batch(
+ [
+ "SELECT 1+1",
+ "SELECT 1 AS one, 2 AS two",
+ { sql: "SELECT ?", args: ["boomerang"] },
+ { sql: "VALUES (?), (?)", args: ["big", "ben"] },
+ ],
+ "read",
+ );
+
+ expect(rss.length).toStrictEqual(4);
+ const [rs0, rs1, rs2, rs3] = rss;
+
+ expect(rs0.rows.length).toStrictEqual(1);
+ expect(Array.from(rs0.rows[0])).toStrictEqual([2]);
+
+ expect(rs1.rows.length).toStrictEqual(1);
+ expect(Array.from(rs1.rows[0])).toStrictEqual([1, 2]);
+
+ expect(rs2.rows.length).toStrictEqual(1);
+ expect(Array.from(rs2.rows[0])).toStrictEqual(["boomerang"]);
+
+ expect(rs3.rows.length).toStrictEqual(2);
+ expect(Array.from(rs3.rows[0])).toStrictEqual(["big"]);
+ expect(Array.from(rs3.rows[1])).toStrictEqual(["ben"]);
+ }),
+ );
+
+ test(
+ "statements are executed sequentially",
+ withClient(async (c) => {
+ const rss = await c.batch(
+ [
+ /* 0 */ "DROP TABLE IF EXISTS t",
+ /* 1 */ "CREATE TABLE t (a, b)",
+ /* 2 */ "INSERT INTO t VALUES (1, 'one')",
+ /* 3 */ "SELECT * FROM t ORDER BY a",
+ /* 4 */ "INSERT INTO t VALUES (2, 'two')",
+ /* 5 */ "SELECT * FROM t ORDER BY a",
+ /* 6 */ "DROP TABLE t",
+ ],
+ "write",
+ );
+
+ expect(rss.length).toStrictEqual(7);
+ expect(rss[3].rows).toEqual([{ a: 1, b: "one" }]);
+ expect(rss[5].rows).toEqual([
+ { a: 1, b: "one" },
+ { a: 2, b: "two" },
+ ]);
+ }),
+ );
+
+ test(
+ "statements are executed in a transaction",
+ withClient(async (c) => {
+ await c.batch(
+ [
+ "DROP TABLE IF EXISTS t1",
+ "DROP TABLE IF EXISTS t2",
+ "CREATE TABLE t1 (a)",
+ "CREATE TABLE t2 (a)",
+ ],
+ "write",
+ );
+
+ const n = 100;
+ const promises = [];
+ for (let i = 0; i < n; ++i) {
+ const ii = i;
+ promises.push(
+ (async () => {
+ const rss = await c.batch(
+ [
+ {
+ sql: "INSERT INTO t1 VALUES (?)",
+ args: [ii],
+ },
+ {
+ sql: "INSERT INTO t2 VALUES (?)",
+ args: [ii * 10],
+ },
+ "SELECT SUM(a) FROM t1",
+ "SELECT SUM(a) FROM t2",
+ ],
+ "write",
+ );
+
+ const sum1 = rss[2].rows[0][0] as number;
+ const sum2 = rss[3].rows[0][0] as number;
+ expect(sum2).toStrictEqual(sum1 * 10);
+ })(),
+ );
+ }
+ await Promise.all(promises);
+
+ const rs1 = await c.execute("SELECT SUM(a) FROM t1");
+ expect(rs1.rows[0][0]).toStrictEqual((n * (n - 1)) / 2);
+ const rs2 = await c.execute("SELECT SUM(a) FROM t2");
+ expect(rs2.rows[0][0]).toStrictEqual(((n * (n - 1)) / 2) * 10);
+ }),
+ 10000,
+ );
+
+ test(
+ "error in batch",
+ withClient(async (c) => {
+ await expect(
+ c.batch(["SELECT 1+1", "SELECT foobar"], "read"),
+ ).rejects.toBeLibsqlError();
+ }),
+ );
+
+ test(
+ "error in batch rolls back transaction",
+ withClient(async (c) => {
+ await c.execute("DROP TABLE IF EXISTS t");
+ await c.execute("CREATE TABLE t (a)");
+ await c.execute("INSERT INTO t VALUES ('one')");
+ await expect(
+ c.batch(
+ [
+ "INSERT INTO t VALUES ('two')",
+ "SELECT foobar",
+ "INSERT INTO t VALUES ('three')",
+ ],
+ "write",
+ ),
+ ).rejects.toBeLibsqlError();
+
+ const rs = await c.execute("SELECT COUNT(*) FROM t");
+ expect(rs.rows[0][0]).toStrictEqual(1);
+ }),
+ );
+
+ test(
+ "batch with a lot of different statements",
+ withClient(async (c) => {
+ const stmts = [];
+ for (let i = 0; i < 1000; ++i) {
+ stmts.push(`SELECT ${i}`);
+ }
+ const rss = await c.batch(stmts, "read");
+ for (let i = 0; i < stmts.length; ++i) {
+ expect(rss[i].rows[0][0]).toStrictEqual(i);
+ }
+ }),
+ );
+
+ test(
+ "batch with a lot of the same statements",
+ withClient(async (c) => {
+ const n = 20;
+ const m = 200;
+
+ const stmts = [];
+ for (let i = 0; i < n; ++i) {
+ for (let j = 0; j < m; ++j) {
+ stmts.push({ sql: `SELECT ?, ${j}`, args: [i] });
+ }
}
- }
- const rss = await c.batch(stmts, "read");
- for (let i = 0; i < n; ++i) {
- for (let j = 0; j < m; ++j) {
- const rs = rss[i*m + j];
- expect(rs.rows[0][0]).toStrictEqual(i);
- expect(rs.rows[0][1]).toStrictEqual(j);
+ const rss = await c.batch(stmts, "read");
+ for (let i = 0; i < n; ++i) {
+ for (let j = 0; j < m; ++j) {
+ const rs = rss[i * m + j];
+ expect(rs.rows[0][0]).toStrictEqual(i);
+ expect(rs.rows[0][1]).toStrictEqual(j);
+ }
}
- }
- }));
-
- test("deferred batch", withClient(async (c) => {
- const rss = await c.batch([
- "SELECT 1+1",
- "DROP TABLE IF EXISTS t",
- "CREATE TABLE t (a)",
- "INSERT INTO t VALUES (21) RETURNING 2*a",
- ], "deferred");
-
- expect(rss.length).toStrictEqual(4);
- const [rs0, _rs1, _rs2, rs3] = rss;
-
- expect(rs0.rows.length).toStrictEqual(1);
- expect(Array.from(rs0.rows[0])).toStrictEqual([2]);
-
- expect(rs3.rows.length).toStrictEqual(1);
- expect(Array.from(rs3.rows[0])).toStrictEqual([42]);
- }));
-
- (hasHrana3 ? test : test.skip)("ROLLBACK statement stops execution of batch", withClient(async (c) => {
- await c.execute("DROP TABLE IF EXISTS t");
- await c.execute("CREATE TABLE t (a)");
-
- await expect(c.batch([
- "INSERT INTO t VALUES (1), (2), (3)",
- "ROLLBACK",
- "INSERT INTO t VALUES (4), (5)",
- ], "write")).rejects.toBeLibsqlError("TRANSACTION_CLOSED");
-
- const rs = await c.execute("SELECT COUNT(*) FROM t");
- expect(rs.rows[0][0]).toStrictEqual(0);
- }));
+ }),
+ );
+
+ test(
+ "deferred batch",
+ withClient(async (c) => {
+ const rss = await c.batch(
+ [
+ "SELECT 1+1",
+ "DROP TABLE IF EXISTS t",
+ "CREATE TABLE t (a)",
+ "INSERT INTO t VALUES (21) RETURNING 2*a",
+ ],
+ "deferred",
+ );
+
+ expect(rss.length).toStrictEqual(4);
+ const [rs0, _rs1, _rs2, rs3] = rss;
+
+ expect(rs0.rows.length).toStrictEqual(1);
+ expect(Array.from(rs0.rows[0])).toStrictEqual([2]);
+
+ expect(rs3.rows.length).toStrictEqual(1);
+ expect(Array.from(rs3.rows[0])).toStrictEqual([42]);
+ }),
+ );
+
+ (hasHrana3 ? test : test.skip)(
+ "ROLLBACK statement stops execution of batch",
+ withClient(async (c) => {
+ await c.execute("DROP TABLE IF EXISTS t");
+ await c.execute("CREATE TABLE t (a)");
+
+ await expect(
+ c.batch(
+ [
+ "INSERT INTO t VALUES (1), (2), (3)",
+ "ROLLBACK",
+ "INSERT INTO t VALUES (4), (5)",
+ ],
+ "write",
+ ),
+ ).rejects.toBeLibsqlError("TRANSACTION_CLOSED");
+
+ const rs = await c.execute("SELECT COUNT(*) FROM t");
+ expect(rs.rows[0][0]).toStrictEqual(0);
+ }),
+ );
});
describe("transaction()", () => {
- test("query multiple rows", withClient(async (c) => {
- const txn = await c.transaction("read");
-
- const rs = await txn.execute("VALUES (1, 'one'), (2, 'two'), (3, 'three')");
- expect(rs.columns.length).toStrictEqual(2);
- expect(rs.columnTypes.length).toStrictEqual(2);
- expect(rs.rows.length).toStrictEqual(3);
-
- expect(Array.from(rs.rows[0])).toStrictEqual([1, "one"]);
- expect(Array.from(rs.rows[1])).toStrictEqual([2, "two"]);
- expect(Array.from(rs.rows[2])).toStrictEqual([3, "three"]);
-
- txn.close();
- }));
-
- test("commit()", withClient(async (c) => {
- await c.batch([
- "DROP TABLE IF EXISTS t",
- "CREATE TABLE t (a)",
- ], "write");
-
- const txn = await c.transaction("write");
- await txn.execute("INSERT INTO t VALUES ('one')");
- await txn.execute("INSERT INTO t VALUES ('two')");
- expect(txn.closed).toStrictEqual(false);
- await txn.commit();
- expect(txn.closed).toStrictEqual(true);
-
- const rs = await c.execute("SELECT COUNT(*) FROM t");
- expect(rs.rows[0][0]).toStrictEqual(2);
- await expect(txn.execute("SELECT 1")).rejects.toBeLibsqlError("TRANSACTION_CLOSED");
- }));
-
- test("rollback()", withClient(async (c) => {
- await c.batch([
- "DROP TABLE IF EXISTS t",
- "CREATE TABLE t (a)",
- ], "write");
-
- const txn = await c.transaction("write");
- await txn.execute("INSERT INTO t VALUES ('one')");
- await txn.execute("INSERT INTO t VALUES ('two')");
- expect(txn.closed).toStrictEqual(false);
- await txn.rollback();
- expect(txn.closed).toStrictEqual(true);
-
- const rs = await c.execute("SELECT COUNT(*) FROM t");
- expect(rs.rows[0][0]).toStrictEqual(0);
- await expect(txn.execute("SELECT 1")).rejects.toBeLibsqlError("TRANSACTION_CLOSED");
- }));
-
- test("close()", withClient(async (c) => {
- await c.batch([
- "DROP TABLE IF EXISTS t",
- "CREATE TABLE t (a)",
- ], "write");
-
- const txn = await c.transaction("write");
- await txn.execute("INSERT INTO t VALUES ('one')");
- expect(txn.closed).toStrictEqual(false);
- txn.close();
- expect(txn.closed).toStrictEqual(true);
-
- const rs = await c.execute("SELECT COUNT(*) FROM t");
- expect(rs.rows[0][0]).toStrictEqual(0);
- await expect(txn.execute("SELECT 1")).rejects.toBeLibsqlError("TRANSACTION_CLOSED");
- }));
-
- test("error does not rollback", withClient(async (c) => {
- await c.batch([
- "DROP TABLE IF EXISTS t",
- "CREATE TABLE t (a)",
- ], "write");
-
- const txn = await c.transaction("write");
- await expect(txn.execute("SELECT foo")).rejects.toBeLibsqlError();
- await txn.execute("INSERT INTO t VALUES ('one')");
- await expect(txn.execute("SELECT bar")).rejects.toBeLibsqlError();
- await txn.commit();
-
- const rs = await c.execute("SELECT COUNT(*) FROM t");
- expect(rs.rows[0][0]).toStrictEqual(1);
- }));
+ test(
+ "query multiple rows",
+ withClient(async (c) => {
+ const txn = await c.transaction("read");
- (hasHrana3 ? test : test.skip)(
- "ROLLBACK statement stops execution of transaction",
- withClient(async (c) =>
- {
- await c.execute("DROP TABLE IF EXISTS t");
- await c.execute("CREATE TABLE t (a)");
-
- const txn = await c.transaction("write");
- const prom1 = txn.execute("INSERT INTO t VALUES (1), (2), (3)");
- const prom2 = txn.execute("ROLLBACK");
- const prom3 = txn.execute("INSERT INTO t VALUES (4), (5)");
-
- await prom1;
- await prom2;
- await expect(prom3).rejects.toBeLibsqlError("TRANSACTION_CLOSED");
- await expect(txn.commit()).rejects.toBeLibsqlError();
- txn.close();
-
- const rs = await c.execute("SELECT COUNT(*) FROM t");
- expect(rs.rows[0][0]).toStrictEqual(0);
- }));
+ const rs = await txn.execute(
+ "VALUES (1, 'one'), (2, 'two'), (3, 'three')",
+ );
+ expect(rs.columns.length).toStrictEqual(2);
+ expect(rs.columnTypes.length).toStrictEqual(2);
+ expect(rs.rows.length).toStrictEqual(3);
- (hasHrana3 ? test : test.skip)(
- "OR ROLLBACK statement stops execution of transaction",
- withClient(async (c) =>
- {
- await c.execute("DROP TABLE IF EXISTS t");
- await c.execute("CREATE TABLE t (a UNIQUE)");
-
- const txn = await c.transaction("write");
- const prom1 = txn.execute("INSERT INTO t VALUES (1), (2), (3)");
- const prom2 = txn.execute("INSERT OR ROLLBACK INTO t VALUES (1)");
- const prom3 = txn.execute("INSERT INTO t VALUES (4), (5)");
-
- await prom1;
- await expect(prom2).rejects.toBeLibsqlError();
- await expect(prom3).rejects.toBeLibsqlError("TRANSACTION_CLOSED");
- await expect(txn.commit()).rejects.toBeLibsqlError();
- txn.close();
-
- const rs = await c.execute("SELECT COUNT(*) FROM t");
- expect(rs.rows[0][0]).toStrictEqual(0);
- }));
+ expect(Array.from(rs.rows[0])).toStrictEqual([1, "one"]);
+ expect(Array.from(rs.rows[1])).toStrictEqual([2, "two"]);
+ expect(Array.from(rs.rows[2])).toStrictEqual([3, "three"]);
- (hasHrana3 ? test : test.skip)(
- "OR ROLLBACK as the first statement stops execution of transaction",
- withClient(async (c) =>
- {
- await c.execute("DROP TABLE IF EXISTS t");
- await c.execute("CREATE TABLE t (a UNIQUE)");
- await c.execute("INSERT INTO t VALUES (1), (2), (3)");
-
- const txn = await c.transaction("write");
- const prom1 = txn.execute("INSERT OR ROLLBACK INTO t VALUES (1)");
- const prom2 = txn.execute("INSERT INTO t VALUES (4), (5)");
-
- await expect(prom1).rejects.toBeLibsqlError();
- await expect(prom2).rejects.toBeLibsqlError("TRANSACTION_CLOSED");
- await expect(txn.commit()).rejects.toBeLibsqlError();
- txn.close();
-
- const rs = await c.execute("SELECT COUNT(*) FROM t");
- expect(rs.rows[0][0]).toStrictEqual(3);
- }));
-
- test("commit empty", withClient(async (c) => {
- const txn = await c.transaction("read");
- await txn.commit();
- }));
-
- test("rollback empty", withClient(async (c) => {
- const txn = await c.transaction("read");
- await txn.rollback();
- }));
+ txn.close();
+ }),
+ );
+
+ test(
+ "commit()",
+ withClient(async (c) => {
+ await c.batch(
+ ["DROP TABLE IF EXISTS t", "CREATE TABLE t (a)"],
+ "write",
+ );
- describe("batch()", () => {
- test("as the first operation on transaction", withClient(async (c) => {
const txn = await c.transaction("write");
+ await txn.execute("INSERT INTO t VALUES ('one')");
+ await txn.execute("INSERT INTO t VALUES ('two')");
+ expect(txn.closed).toStrictEqual(false);
+ await txn.commit();
+ expect(txn.closed).toStrictEqual(true);
+
+ const rs = await c.execute("SELECT COUNT(*) FROM t");
+ expect(rs.rows[0][0]).toStrictEqual(2);
+ await expect(txn.execute("SELECT 1")).rejects.toBeLibsqlError(
+ "TRANSACTION_CLOSED",
+ );
+ }),
+ );
+
+ test(
+ "rollback()",
+ withClient(async (c) => {
+ await c.batch(
+ ["DROP TABLE IF EXISTS t", "CREATE TABLE t (a)"],
+ "write",
+ );
- await txn.batch([
- "DROP TABLE IF EXISTS t",
- "CREATE TABLE t (a)",
- {sql: "INSERT INTO t VALUES (?)", args: [1]},
- {sql: "INSERT INTO t VALUES (?)", args: [2]},
- {sql: "INSERT INTO t VALUES (?)", args: [4]},
- ]);
+ const txn = await c.transaction("write");
+ await txn.execute("INSERT INTO t VALUES ('one')");
+ await txn.execute("INSERT INTO t VALUES ('two')");
+ expect(txn.closed).toStrictEqual(false);
+ await txn.rollback();
+ expect(txn.closed).toStrictEqual(true);
+
+ const rs = await c.execute("SELECT COUNT(*) FROM t");
+ expect(rs.rows[0][0]).toStrictEqual(0);
+ await expect(txn.execute("SELECT 1")).rejects.toBeLibsqlError(
+ "TRANSACTION_CLOSED",
+ );
+ }),
+ );
+
+ test(
+ "close()",
+ withClient(async (c) => {
+ await c.batch(
+ ["DROP TABLE IF EXISTS t", "CREATE TABLE t (a)"],
+ "write",
+ );
- const rs = await txn.execute("SELECT SUM(a) FROM t");
- expect(rs.rows[0][0]).toStrictEqual(7);
+ const txn = await c.transaction("write");
+ await txn.execute("INSERT INTO t VALUES ('one')");
+ expect(txn.closed).toStrictEqual(false);
txn.close();
- }));
+ expect(txn.closed).toStrictEqual(true);
+
+ const rs = await c.execute("SELECT COUNT(*) FROM t");
+ expect(rs.rows[0][0]).toStrictEqual(0);
+ await expect(txn.execute("SELECT 1")).rejects.toBeLibsqlError(
+ "TRANSACTION_CLOSED",
+ );
+ }),
+ );
+
+ test(
+ "error does not rollback",
+ withClient(async (c) => {
+ await c.batch(
+ ["DROP TABLE IF EXISTS t", "CREATE TABLE t (a)"],
+ "write",
+ );
- test("as the second operation on transaction", withClient(async (c) => {
const txn = await c.transaction("write");
+ await expect(txn.execute("SELECT foo")).rejects.toBeLibsqlError();
+ await txn.execute("INSERT INTO t VALUES ('one')");
+ await expect(txn.execute("SELECT bar")).rejects.toBeLibsqlError();
+ await txn.commit();
- await txn.execute("DROP TABLE IF EXISTS t");
- await txn.batch([
- "CREATE TABLE t (a)",
- {sql: "INSERT INTO t VALUES (?)", args: [1]},
- {sql: "INSERT INTO t VALUES (?)", args: [2]},
- {sql: "INSERT INTO t VALUES (?)", args: [4]},
- ]);
+ const rs = await c.execute("SELECT COUNT(*) FROM t");
+ expect(rs.rows[0][0]).toStrictEqual(1);
+ }),
+ );
- const rs = await txn.execute("SELECT SUM(a) FROM t");
- expect(rs.rows[0][0]).toStrictEqual(7);
+ (hasHrana3 ? test : test.skip)(
+ "ROLLBACK statement stops execution of transaction",
+ withClient(async (c) => {
+ await c.execute("DROP TABLE IF EXISTS t");
+ await c.execute("CREATE TABLE t (a)");
+
+ const txn = await c.transaction("write");
+ const prom1 = txn.execute("INSERT INTO t VALUES (1), (2), (3)");
+ const prom2 = txn.execute("ROLLBACK");
+ const prom3 = txn.execute("INSERT INTO t VALUES (4), (5)");
+
+ await prom1;
+ await prom2;
+ await expect(prom3).rejects.toBeLibsqlError("TRANSACTION_CLOSED");
+ await expect(txn.commit()).rejects.toBeLibsqlError();
txn.close();
- }));
- test("after error, further statements are not executed", withClient(async (c) => {
+ const rs = await c.execute("SELECT COUNT(*) FROM t");
+ expect(rs.rows[0][0]).toStrictEqual(0);
+ }),
+ );
+
+ (hasHrana3 ? test : test.skip)(
+ "OR ROLLBACK statement stops execution of transaction",
+ withClient(async (c) => {
+ await c.execute("DROP TABLE IF EXISTS t");
+ await c.execute("CREATE TABLE t (a UNIQUE)");
+
const txn = await c.transaction("write");
+ const prom1 = txn.execute("INSERT INTO t VALUES (1), (2), (3)");
+ const prom2 = txn.execute("INSERT OR ROLLBACK INTO t VALUES (1)");
+ const prom3 = txn.execute("INSERT INTO t VALUES (4), (5)");
+
+ await prom1;
+ await expect(prom2).rejects.toBeLibsqlError();
+ await expect(prom3).rejects.toBeLibsqlError("TRANSACTION_CLOSED");
+ await expect(txn.commit()).rejects.toBeLibsqlError();
+ txn.close();
- await expect(txn.batch([
- "DROP TABLE IF EXISTS t",
- "CREATE TABLE t (a UNIQUE)",
- "INSERT INTO t VALUES (1), (2), (4)",
- "INSERT INTO t VALUES (1)",
- "INSERT INTO t VALUES (8), (16)",
- ])).rejects.toBeLibsqlError();
+ const rs = await c.execute("SELECT COUNT(*) FROM t");
+ expect(rs.rows[0][0]).toStrictEqual(0);
+ }),
+ );
- const rs = await txn.execute("SELECT SUM(a) FROM t");
- expect(rs.rows[0][0]).toStrictEqual(7);
+ (hasHrana3 ? test : test.skip)(
+ "OR ROLLBACK as the first statement stops execution of transaction",
+ withClient(async (c) => {
+ await c.execute("DROP TABLE IF EXISTS t");
+ await c.execute("CREATE TABLE t (a UNIQUE)");
+ await c.execute("INSERT INTO t VALUES (1), (2), (3)");
+
+ const txn = await c.transaction("write");
+ const prom1 = txn.execute("INSERT OR ROLLBACK INTO t VALUES (1)");
+ const prom2 = txn.execute("INSERT INTO t VALUES (4), (5)");
+
+ await expect(prom1).rejects.toBeLibsqlError();
+ await expect(prom2).rejects.toBeLibsqlError("TRANSACTION_CLOSED");
+ await expect(txn.commit()).rejects.toBeLibsqlError();
+ txn.close();
+
+ const rs = await c.execute("SELECT COUNT(*) FROM t");
+ expect(rs.rows[0][0]).toStrictEqual(3);
+ }),
+ );
+ test(
+ "commit empty",
+ withClient(async (c) => {
+ const txn = await c.transaction("read");
await txn.commit();
- }));
+ }),
+ );
+
+ test(
+ "rollback empty",
+ withClient(async (c) => {
+ const txn = await c.transaction("read");
+ await txn.rollback();
+ }),
+ );
+
+ describe("batch()", () => {
+ test(
+ "as the first operation on transaction",
+ withClient(async (c) => {
+ const txn = await c.transaction("write");
+
+ await txn.batch([
+ "DROP TABLE IF EXISTS t",
+ "CREATE TABLE t (a)",
+ { sql: "INSERT INTO t VALUES (?)", args: [1] },
+ { sql: "INSERT INTO t VALUES (?)", args: [2] },
+ { sql: "INSERT INTO t VALUES (?)", args: [4] },
+ ]);
+
+ const rs = await txn.execute("SELECT SUM(a) FROM t");
+ expect(rs.rows[0][0]).toStrictEqual(7);
+ txn.close();
+ }),
+ );
+
+ test(
+ "as the second operation on transaction",
+ withClient(async (c) => {
+ const txn = await c.transaction("write");
+
+ await txn.execute("DROP TABLE IF EXISTS t");
+ await txn.batch([
+ "CREATE TABLE t (a)",
+ { sql: "INSERT INTO t VALUES (?)", args: [1] },
+ { sql: "INSERT INTO t VALUES (?)", args: [2] },
+ { sql: "INSERT INTO t VALUES (?)", args: [4] },
+ ]);
+
+ const rs = await txn.execute("SELECT SUM(a) FROM t");
+ expect(rs.rows[0][0]).toStrictEqual(7);
+ txn.close();
+ }),
+ );
+
+ test(
+ "after error, further statements are not executed",
+ withClient(async (c) => {
+ const txn = await c.transaction("write");
+
+ await expect(
+ txn.batch([
+ "DROP TABLE IF EXISTS t",
+ "CREATE TABLE t (a UNIQUE)",
+ "INSERT INTO t VALUES (1), (2), (4)",
+ "INSERT INTO t VALUES (1)",
+ "INSERT INTO t VALUES (8), (16)",
+ ]),
+ ).rejects.toBeLibsqlError();
+
+ const rs = await txn.execute("SELECT SUM(a) FROM t");
+ expect(rs.rows[0][0]).toStrictEqual(7);
+
+ await txn.commit();
+ }),
+ );
});
(hasHrana2 ? describe : describe.skip)("executeMultiple()", () => {
- test("as the first operation on transaction", withClient(async (c) => {
- const txn = await c.transaction("write");
+ test(
+ "as the first operation on transaction",
+ withClient(async (c) => {
+ const txn = await c.transaction("write");
- await txn.executeMultiple(`
+ await txn.executeMultiple(`
DROP TABLE IF EXISTS t;
CREATE TABLE t (a);
INSERT INTO t VALUES (1), (2), (4), (8);
`);
- const rs = await txn.execute("SELECT SUM(a) FROM t");
- expect(rs.rows[0][0]).toStrictEqual(15);
- txn.close();
- }));
+ const rs = await txn.execute("SELECT SUM(a) FROM t");
+ expect(rs.rows[0][0]).toStrictEqual(15);
+ txn.close();
+ }),
+ );
- test("as the second operation on transaction", withClient(async (c) => {
- const txn = await c.transaction("write");
- await txn.execute("DROP TABLE IF EXISTS t");
- await txn.executeMultiple(`
+ test(
+ "as the second operation on transaction",
+ withClient(async (c) => {
+ const txn = await c.transaction("write");
+ await txn.execute("DROP TABLE IF EXISTS t");
+ await txn.executeMultiple(`
CREATE TABLE t (a);
INSERT INTO t VALUES (1), (2), (4), (8);
`);
- const rs = await txn.execute("SELECT SUM(a) FROM t");
- expect(rs.rows[0][0]).toStrictEqual(15);
- txn.close();
- }));
+ const rs = await txn.execute("SELECT SUM(a) FROM t");
+ expect(rs.rows[0][0]).toStrictEqual(15);
+ txn.close();
+ }),
+ );
- test("after error, further statements are not executed", withClient(async (c) => {
- const txn = await c.transaction("write");
+ test(
+ "after error, further statements are not executed",
+ withClient(async (c) => {
+ const txn = await c.transaction("write");
- await expect(txn.executeMultiple(`
+ await expect(
+ txn.executeMultiple(`
DROP TABLE IF EXISTS t;
CREATE TABLE t (a UNIQUE);
INSERT INTO t VALUES (1), (2), (4);
INSERT INTO t VALUES (1);
INSERT INTO t VALUES (8), (16);
- `)).rejects.toBeLibsqlError();
+ `),
+ ).rejects.toBeLibsqlError();
- const rs = await txn.execute("SELECT SUM(a) FROM t");
- expect(rs.rows[0][0]).toStrictEqual(7);
+ const rs = await txn.execute("SELECT SUM(a) FROM t");
+ expect(rs.rows[0][0]).toStrictEqual(7);
- await txn.commit();
- }));
+ await txn.commit();
+ }),
+ );
});
});
(hasHrana2 ? describe : describe.skip)("executeMultiple()", () => {
- test("multiple statements", withClient(async (c) => {
- await c.executeMultiple(`
+ test(
+ "multiple statements",
+ withClient(async (c) => {
+ await c.executeMultiple(`
DROP TABLE IF EXISTS t;
CREATE TABLE t (a);
INSERT INTO t VALUES (1), (2), (4), (8);
`);
- const rs = await c.execute("SELECT SUM(a) FROM t");
- expect(rs.rows[0][0]).toStrictEqual(15);
- }));
-
- test("after an error, statements are not executed", withClient(async (c) => {
- await expect(c.executeMultiple(`
+ const rs = await c.execute("SELECT SUM(a) FROM t");
+ expect(rs.rows[0][0]).toStrictEqual(15);
+ }),
+ );
+
+ test(
+ "after an error, statements are not executed",
+ withClient(async (c) => {
+ await expect(
+ c.executeMultiple(`
DROP TABLE IF EXISTS t;
CREATE TABLE t (a);
INSERT INTO t VALUES (1), (2), (4);
INSERT INTO t VALUES (foo());
INSERT INTO t VALUES (8), (16);
- `)).rejects.toBeLibsqlError();
+ `),
+ ).rejects.toBeLibsqlError();
- const rs = await c.execute("SELECT SUM(a) FROM t");
- expect(rs.rows[0][0]).toStrictEqual(7);
- }));
+ const rs = await c.execute("SELECT SUM(a) FROM t");
+ expect(rs.rows[0][0]).toStrictEqual(7);
+ }),
+ );
- test("manual transaction control statements", withClient(async (c) => {
- await c.executeMultiple(`
+ test(
+ "manual transaction control statements",
+ withClient(async (c) => {
+ await c.executeMultiple(`
DROP TABLE IF EXISTS t;
CREATE TABLE t (a);
BEGIN;
@@ -911,12 +1281,16 @@ describe("transaction()", () => {
COMMIT;
`);
- const rs = await c.execute("SELECT SUM(a) FROM t");
- expect(rs.rows[0][0]).toStrictEqual(31);
- }));
+ const rs = await c.execute("SELECT SUM(a) FROM t");
+ expect(rs.rows[0][0]).toStrictEqual(31);
+ }),
+ );
- test("error rolls back a manual transaction", withClient(async (c) => {
- await expect(c.executeMultiple(`
+ test(
+ "error rolls back a manual transaction",
+ withClient(async (c) => {
+ await expect(
+ c.executeMultiple(`
DROP TABLE IF EXISTS t;
CREATE TABLE t (a);
INSERT INTO t VALUES (0);
@@ -925,41 +1299,65 @@ describe("transaction()", () => {
INSERT INTO t VALUES (foo());
INSERT INTO t VALUES (8), (16);
COMMIT;
- `)).rejects.toBeLibsqlError();
+ `),
+ ).rejects.toBeLibsqlError();
- const rs = await c.execute("SELECT SUM(a) FROM t");
- expect(rs.rows[0][0]).toStrictEqual(0);
- }));
+ const rs = await c.execute("SELECT SUM(a) FROM t");
+ expect(rs.rows[0][0]).toStrictEqual(0);
+ }),
+ );
});
(hasNetworkErrors ? describe : describe.skip)("network errors", () => {
const testCases = [
- {title: "WebSocket close", sql: ".close_ws"},
- {title: "TCP close", sql: ".close_tcp"},
+ { title: "WebSocket close", sql: ".close_ws" },
+ { title: "TCP close", sql: ".close_tcp" },
];
- for (const {title, sql} of testCases) {
- test(`${title} in execute()`, withClient(async (c) => {
- await expect(c.execute(sql)).rejects.toBeLibsqlError("HRANA_WEBSOCKET_ERROR");
-
- expect((await c.execute("SELECT 42")).rows[0][0]).toStrictEqual(42);
- }));
-
- test(`${title} in transaction()`, withClient(async (c) => {
- const txn = await c.transaction("read");
- await expect(txn.execute(sql)).rejects.toBeLibsqlError("HRANA_WEBSOCKET_ERROR");
- await expect(txn.commit()).rejects.toBeLibsqlError("TRANSACTION_CLOSED");
- txn.close();
-
- expect((await c.execute("SELECT 42")).rows[0][0]).toStrictEqual(42);
- }));
+ for (const { title, sql } of testCases) {
+ test(
+ `${title} in execute()`,
+ withClient(async (c) => {
+ await expect(c.execute(sql)).rejects.toBeLibsqlError(
+ "HRANA_WEBSOCKET_ERROR",
+ );
+
+ expect((await c.execute("SELECT 42")).rows[0][0]).toStrictEqual(
+ 42,
+ );
+ }),
+ );
- test(`${title} in batch()`, withClient(async (c) => {
- await expect(c.batch(["SELECT 42", sql, "SELECT 24"], "read"))
- .rejects.toBeLibsqlError("HRANA_WEBSOCKET_ERROR");
+ test(
+ `${title} in transaction()`,
+ withClient(async (c) => {
+ const txn = await c.transaction("read");
+ await expect(txn.execute(sql)).rejects.toBeLibsqlError(
+ "HRANA_WEBSOCKET_ERROR",
+ );
+ await expect(txn.commit()).rejects.toBeLibsqlError(
+ "TRANSACTION_CLOSED",
+ );
+ txn.close();
+
+ expect((await c.execute("SELECT 42")).rows[0][0]).toStrictEqual(
+ 42,
+ );
+ }),
+ );
- expect((await c.execute("SELECT 42")).rows[0][0]).toStrictEqual(42);
- }));
+ test(
+ `${title} in batch()`,
+ withClient(async (c) => {
+ await expect(
+ c.batch(["SELECT 42", sql, "SELECT 24"], "read"),
+ ).rejects.toBeLibsqlError("HRANA_WEBSOCKET_ERROR");
+
+ expect((await c.execute("SELECT 42")).rows[0][0]).toStrictEqual(
+ 42,
+ );
+ }),
+ );
}
});
@@ -970,7 +1368,7 @@ describe("transaction()", () => {
return fetch(request);
}
- const c = createClient({...config, fetch: customFetch});
+ const c = createClient({ ...config, fetch: customFetch });
try {
const rs = await c.execute("SELECT 42");
expect(rs.rows[0][0]).toStrictEqual(42);
@@ -980,13 +1378,13 @@ describe("transaction()", () => {
}
});
-(isFile ? test : test.skip)('raw error codes', async () => {
- const c = createClient(config)
+(isFile ? test : test.skip)("raw error codes", async () => {
+ const c = createClient(config);
try {
- await expect(c.execute('NOT A VALID SQL')).rejects.toThrow(
- expect.toBeLibsqlError({ code: 'SQLITE_ERROR', rawCode: 1})
- )
+ await expect(c.execute("NOT A VALID SQL")).rejects.toThrow(
+ expect.toBeLibsqlError({ code: "SQLITE_ERROR", rawCode: 1 }),
+ );
} finally {
c.close();
}
-})
+});
diff --git a/packages/libsql-client/src/__tests__/helpers.ts b/packages/libsql-client/src/__tests__/helpers.ts
index 1a0a5185..ad8b5207 100644
--- a/packages/libsql-client/src/__tests__/helpers.ts
+++ b/packages/libsql-client/src/__tests__/helpers.ts
@@ -4,46 +4,48 @@ import type { MatcherFunction } from "expect";
import { LibsqlError } from "../node.js";
type CodeMatch = {
- code: string,
- rawCode: number
-}
-
-const toBeLibsqlError: MatcherFunction<[code?: string | CodeMatch, message?: RegExp]> =
- function (actual, code?, messageRe?) {
- const pass = actual instanceof LibsqlError
- && isValidCode(actual, code)
- && (messageRe === undefined || actual.message.match(messageRe) !== null);
+ code: string;
+ rawCode: number;
+};
- const message = (): string => {
- const parts = [];
- parts.push("expected ");
- parts.push(this.utils.printReceived(actual));
- parts.push(pass ? " not to be " : " to be ");
- parts.push("an instance of LibsqlError");
- if (code !== undefined) {
- parts.push(" with error code ");
- parts.push(this.utils.printExpected(code));
- }
- if (messageRe !== undefined) {
- parts.push(" with error message matching ");
- parts.push(this.utils.printExpected(messageRe));
- }
- return parts.join("");
- };
+const toBeLibsqlError: MatcherFunction<
+ [code?: string | CodeMatch, message?: RegExp]
+> = function (actual, code?, messageRe?) {
+ const pass =
+ actual instanceof LibsqlError &&
+ isValidCode(actual, code) &&
+ (messageRe === undefined || actual.message.match(messageRe) !== null);
- return {pass, message};
+ const message = (): string => {
+ const parts = [];
+ parts.push("expected ");
+ parts.push(this.utils.printReceived(actual));
+ parts.push(pass ? " not to be " : " to be ");
+ parts.push("an instance of LibsqlError");
+ if (code !== undefined) {
+ parts.push(" with error code ");
+ parts.push(this.utils.printExpected(code));
+ }
+ if (messageRe !== undefined) {
+ parts.push(" with error message matching ");
+ parts.push(this.utils.printExpected(messageRe));
+ }
+ return parts.join("");
};
+ return { pass, message };
+};
+
const isValidCode = (error: LibsqlError, code?: string | CodeMatch) => {
if (code === undefined) {
- return true
+ return true;
}
- if (typeof code === 'string') {
- return error.code === code
+ if (typeof code === "string") {
+ return error.code === code;
}
- return error.code === code.code && error.rawCode === code.rawCode
-}
-expect.extend({toBeLibsqlError});
+ return error.code === code.code && error.rawCode === code.rawCode;
+};
+expect.extend({ toBeLibsqlError });
declare module "expect" {
interface AsymmetricMatchers {
toBeLibsqlError(code?: string | CodeMatch, messageRe?: RegExp): void;
diff --git a/packages/libsql-client/src/__tests__/uri.test.ts b/packages/libsql-client/src/__tests__/uri.test.ts
index a0bae4ac..a8af85a9 100644
--- a/packages/libsql-client/src/__tests__/uri.test.ts
+++ b/packages/libsql-client/src/__tests__/uri.test.ts
@@ -8,15 +8,15 @@ import { parseUri, encodeBaseUrl } from "@libsql/core/uri";
describe("parseUri()", () => {
test("authority and path", () => {
const cases = [
- {text: "file://localhost", path: ""},
- {text: "file://localhost/", path: "/"},
- {text: "file://localhost/absolute/path", path: "/absolute/path"},
- {text: "file://localhost/k%C5%AF%C5%88", path: "/kůň"},
+ { text: "file://localhost", path: "" },
+ { text: "file://localhost/", path: "/" },
+ { text: "file://localhost/absolute/path", path: "/absolute/path" },
+ { text: "file://localhost/k%C5%AF%C5%88", path: "/kůň" },
];
- for (const {text, path} of cases) {
+ for (const { text, path } of cases) {
expect(parseUri(text)).toEqual({
scheme: "file",
- authority: {host: "localhost"},
+ authority: { host: "localhost" },
path,
});
}
@@ -24,14 +24,14 @@ describe("parseUri()", () => {
test("empty authority and path", () => {
const cases = [
- {text: "file:///absolute/path", path: "/absolute/path"},
- {text: "file://", path: ""},
- {text: "file:///k%C5%AF%C5%88", path: "/kůň"},
+ { text: "file:///absolute/path", path: "/absolute/path" },
+ { text: "file://", path: "" },
+ { text: "file:///k%C5%AF%C5%88", path: "/kůň" },
];
- for (const {text, path} of cases) {
+ for (const { text, path } of cases) {
expect(parseUri(text)).toEqual({
scheme: "file",
- authority: {host: ""},
+ authority: { host: "" },
path,
});
}
@@ -39,13 +39,13 @@ describe("parseUri()", () => {
test("no authority and path", () => {
const cases = [
- {text: "file:/absolute/path", path: "/absolute/path"},
- {text: "file:relative/path", path: "relative/path"},
- {text: "file:", path: ""},
- {text: "file:C:/path/to/file", path: "C:/path/to/file"},
- {text: "file:k%C5%AF%C5%88", path: "kůň"},
+ { text: "file:/absolute/path", path: "/absolute/path" },
+ { text: "file:relative/path", path: "relative/path" },
+ { text: "file:", path: "" },
+ { text: "file:C:/path/to/file", path: "C:/path/to/file" },
+ { text: "file:k%C5%AF%C5%88", path: "kůň" },
];
- for (const {text, path} of cases) {
+ for (const { text, path } of cases) {
expect(parseUri(text)).toEqual({
scheme: "file",
path,
@@ -55,39 +55,48 @@ describe("parseUri()", () => {
test("authority", () => {
const hosts = [
- {text: "localhost", host: "localhost"},
- {text: "domain.name", host: "domain.name"},
- {text: "some$weird.%20!name", host: "some$weird. !name"},
- {text: "1.20.255.99", host: "1.20.255.99"},
- {text: "[2001:4860:4802:32::a]", host: "2001:4860:4802:32::a"},
- {text: "%61", host: "a"},
- {text: "100%2e100%2e100%2e100", host: "100.100.100.100"},
- {text: "k%C5%AF%C5%88", host: "kůň"},
+ { text: "localhost", host: "localhost" },
+ { text: "domain.name", host: "domain.name" },
+ { text: "some$weird.%20!name", host: "some$weird. !name" },
+ { text: "1.20.255.99", host: "1.20.255.99" },
+ { text: "[2001:4860:4802:32::a]", host: "2001:4860:4802:32::a" },
+ { text: "%61", host: "a" },
+ { text: "100%2e100%2e100%2e100", host: "100.100.100.100" },
+ { text: "k%C5%AF%C5%88", host: "kůň" },
];
const ports = [
- {text: "", port: undefined},
- {text: ":", port: undefined},
- {text: ":0", port: 0},
- {text: ":99", port: 99},
- {text: ":65535", port: 65535},
+ { text: "", port: undefined },
+ { text: ":", port: undefined },
+ { text: ":0", port: 0 },
+ { text: ":99", port: 99 },
+ { text: ":65535", port: 65535 },
];
const userinfos = [
- {text: "", userinfo: undefined},
- {text: "@", userinfo: {username: ""}},
- {text: "alice@", userinfo: {username: "alice"}},
- {text: "alice:secret@", userinfo: {username: "alice", password: "secret"}},
- {text: "alice:sec:et@", userinfo: {username: "alice", password: "sec:et"}},
- {text: "alice%3Asecret@", userinfo: {username: "alice:secret"}},
- {text: "alice:s%65cret@", userinfo: {username: "alice", password: "secret"}},
+ { text: "", userinfo: undefined },
+ { text: "@", userinfo: { username: "" } },
+ { text: "alice@", userinfo: { username: "alice" } },
+ {
+ text: "alice:secret@",
+ userinfo: { username: "alice", password: "secret" },
+ },
+ {
+ text: "alice:sec:et@",
+ userinfo: { username: "alice", password: "sec:et" },
+ },
+ { text: "alice%3Asecret@", userinfo: { username: "alice:secret" } },
+ {
+ text: "alice:s%65cret@",
+ userinfo: { username: "alice", password: "secret" },
+ },
];
- for (const {text: hostText, host} of hosts) {
- for (const {text: portText, port} of ports) {
- for (const {text: userText, userinfo} of userinfos) {
+ for (const { text: hostText, host } of hosts) {
+ for (const { text: portText, port } of ports) {
+ for (const { text: userText, userinfo } of userinfos) {
const text = `http://${userText}${hostText}${portText}`;
expect(parseUri(text)).toEqual({
scheme: "http",
- authority: {host, port, userinfo},
+ authority: { host, port, userinfo },
path: "",
});
}
@@ -97,82 +106,51 @@ describe("parseUri()", () => {
test("query", () => {
const cases = [
- {text: "?", pairs: []},
- {text: "?key=value", pairs: [
- {key: "key", value: "value"},
- ]},
- {text: "?&key=value", pairs: [
- {key: "key", value: "value"},
- ]},
- {text: "?key=value&&", pairs: [
- {key: "key", value: "value"},
- ]},
- {text: "?a", pairs: [
- {key: "a", value: ""},
- ]},
- {text: "?a=", pairs: [
- {key: "a", value: ""},
- ]},
- {text: "?=a", pairs: [
- {key: "", value: "a"},
- ]},
- {text: "?=", pairs: [
- {key: "", value: ""},
- ]},
- {text: "?a=b=c", pairs: [
- {key: "a", value: "b=c"},
- ]},
- {text: "?a=b&c=d", pairs: [
- {key: "a", value: "b"},
- {key: "c", value: "d"},
- ]},
- {text: "?a+b=c", pairs: [
- {key: "a b", value: "c"},
- ]},
- {text: "?a=b+c", pairs: [
- {key: "a", value: "b c"},
- ]},
- {text: "?a?b", pairs: [
- {key: "a?b", value: ""},
- ]},
- {text: "?%61=%62", pairs: [
- {key: "a", value: "b"},
- ]},
- {text: "?a%3db", pairs: [
- {key: "a=b", value: ""},
- ]},
- {text: "?a=%2b", pairs: [
- {key: "a", value: "+"},
- ]},
- {text: "?%2b=b", pairs: [
- {key: "+", value: "b"},
- ]},
- {text: "?a=b%26c", pairs: [
- {key: "a", value: "b&c"},
- ]},
- {text: "?a=k%C5%AF%C5%88", pairs: [
- {key: "a", value: "kůň"},
- ]},
+ { text: "?", pairs: [] },
+ { text: "?key=value", pairs: [{ key: "key", value: "value" }] },
+ { text: "?&key=value", pairs: [{ key: "key", value: "value" }] },
+ { text: "?key=value&&", pairs: [{ key: "key", value: "value" }] },
+ { text: "?a", pairs: [{ key: "a", value: "" }] },
+ { text: "?a=", pairs: [{ key: "a", value: "" }] },
+ { text: "?=a", pairs: [{ key: "", value: "a" }] },
+ { text: "?=", pairs: [{ key: "", value: "" }] },
+ { text: "?a=b=c", pairs: [{ key: "a", value: "b=c" }] },
+ {
+ text: "?a=b&c=d",
+ pairs: [
+ { key: "a", value: "b" },
+ { key: "c", value: "d" },
+ ],
+ },
+ { text: "?a+b=c", pairs: [{ key: "a b", value: "c" }] },
+ { text: "?a=b+c", pairs: [{ key: "a", value: "b c" }] },
+ { text: "?a?b", pairs: [{ key: "a?b", value: "" }] },
+ { text: "?%61=%62", pairs: [{ key: "a", value: "b" }] },
+ { text: "?a%3db", pairs: [{ key: "a=b", value: "" }] },
+ { text: "?a=%2b", pairs: [{ key: "a", value: "+" }] },
+ { text: "?%2b=b", pairs: [{ key: "+", value: "b" }] },
+ { text: "?a=b%26c", pairs: [{ key: "a", value: "b&c" }] },
+ { text: "?a=k%C5%AF%C5%88", pairs: [{ key: "a", value: "kůň" }] },
];
- for (const {text: queryText, pairs} of cases) {
+ for (const { text: queryText, pairs } of cases) {
const text = `file:${queryText}`;
expect(parseUri(text)).toEqual({
scheme: "file",
path: "",
- query: {pairs},
+ query: { pairs },
});
}
});
test("fragment", () => {
const cases = [
- {text: "", fragment: undefined},
- {text: "#a", fragment: "a"},
- {text: "#a?b", fragment: "a?b"},
- {text: "#%61", fragment: "a"},
- {text: "#k%C5%AF%C5%88", fragment: "kůň"},
+ { text: "", fragment: undefined },
+ { text: "#a", fragment: "a" },
+ { text: "#a?b", fragment: "a?b" },
+ { text: "#%61", fragment: "a" },
+ { text: "#k%C5%AF%C5%88", fragment: "kůň" },
];
- for (const {text: fragmentText, fragment} of cases) {
+ for (const { text: fragmentText, fragment } of cases) {
const text = `file:${fragmentText}`;
expect(parseUri(text)).toEqual({
scheme: "file",
@@ -184,17 +162,19 @@ describe("parseUri()", () => {
test("parse errors", () => {
const cases = [
- {text: "", message: /format/},
- {text: "foo", message: /format/},
- {text: "foo.bar.com", message: /format/},
- {text: "h$$p://localhost", message: /format/},
- {text: "h%74%74p://localhost", message: /format/},
- {text: "http://localhost:%38%38", message: /authority/},
- {text: "file:k%C5%C5%88", message: /percent encoding/},
+ { text: "", message: /format/ },
+ { text: "foo", message: /format/ },
+ { text: "foo.bar.com", message: /format/ },
+ { text: "h$$p://localhost", message: /format/ },
+ { text: "h%74%74p://localhost", message: /format/ },
+ { text: "http://localhost:%38%38", message: /authority/ },
+ { text: "file:k%C5%C5%88", message: /percent encoding/ },
];
- for (const {text, message} of cases) {
- expect(() => parseUri(text)).toThrow(expect.toBeLibsqlError("URL_INVALID", message));
+ for (const { text, message } of cases) {
+ expect(() => parseUri(text)).toThrow(
+ expect.toBeLibsqlError("URL_INVALID", message),
+ );
}
});
});
@@ -253,28 +233,30 @@ test("encodeBaseUrl()", () => {
{
scheme: "http",
host: "localhost",
- userinfo: {username: "alice", password: undefined},
+ userinfo: { username: "alice", password: undefined },
path: "",
url: "http://alice@localhost",
},
{
scheme: "http",
host: "localhost",
- userinfo: {username: "alice", password: "secr:t"},
+ userinfo: { username: "alice", password: "secr:t" },
path: "",
url: "http://alice:secr%3At@localhost",
},
{
scheme: "https",
host: "localhost",
- userinfo: {username: "alice", password: "secret"},
+ userinfo: { username: "alice", password: "secret" },
port: 8080,
path: "/some/path",
url: "https://alice:secret@localhost:8080/some/path",
},
];
- for (const {scheme, host, port, userinfo, path, url} of cases) {
- expect(encodeBaseUrl(scheme, {host, port, userinfo}, path)).toStrictEqual(new URL(url));
+ for (const { scheme, host, port, userinfo, path, url } of cases) {
+ expect(
+ encodeBaseUrl(scheme, { host, port, userinfo }, path),
+ ).toStrictEqual(new URL(url));
}
});
diff --git a/packages/libsql-client/src/hrana.ts b/packages/libsql-client/src/hrana.ts
index 2796baa7..628bc474 100644
--- a/packages/libsql-client/src/hrana.ts
+++ b/packages/libsql-client/src/hrana.ts
@@ -1,5 +1,10 @@
import * as hrana from "@libsql/hrana-client";
-import type { InStatement, ResultSet, Transaction, TransactionMode } from "@libsql/core/api";
+import type {
+ InStatement,
+ ResultSet,
+ Transaction,
+ TransactionMode,
+} from "@libsql/core/api";
import { LibsqlError } from "@libsql/core/api";
import type { SqlCache } from "./sql_cache.js";
import { transactionModeToBegin, ResultSetImpl } from "@libsql/core/util";
@@ -50,17 +55,24 @@ export abstract class HranaTransaction implements Transaction {
this._getSqlCache().apply(hranaStmts);
const batch = stream.batch(this.#version >= 3);
const beginStep = batch.step();
- const beginPromise = beginStep.run(transactionModeToBegin(this.#mode));
+ const beginPromise = beginStep.run(
+ transactionModeToBegin(this.#mode),
+ );
// Execute the `hranaStmts` only if the BEGIN succeeded, to make sure that we don't execute it
// outside of a transaction.
let lastStep = beginStep;
rowsPromises = hranaStmts.map((hranaStmt) => {
- const stmtStep = batch.step()
+ const stmtStep = batch
+ .step()
.condition(hrana.BatchCond.ok(lastStep));
if (this.#version >= 3) {
// If the Hrana version supports it, make sure that we are still in a transaction
- stmtStep.condition(hrana.BatchCond.not(hrana.BatchCond.isAutocommit(batch)));
+ stmtStep.condition(
+ hrana.BatchCond.not(
+ hrana.BatchCond.isAutocommit(batch),
+ ),
+ );
}
const rowsPromise = stmtStep.query(hranaStmt);
@@ -71,7 +83,8 @@ export abstract class HranaTransaction implements Transaction {
// `this.#started` is resolved successfully only if the batch and the BEGIN statement inside
// of the batch are both successful.
- this.#started = batch.execute()
+ this.#started = batch
+ .execute()
.then(() => beginPromise)
.then(() => undefined);
@@ -104,7 +117,11 @@ export abstract class HranaTransaction implements Transaction {
stmtStep.condition(hrana.BatchCond.ok(lastStep));
}
if (this.#version >= 3) {
- stmtStep.condition(hrana.BatchCond.not(hrana.BatchCond.isAutocommit(batch)));
+ stmtStep.condition(
+ hrana.BatchCond.not(
+ hrana.BatchCond.isAutocommit(batch),
+ ),
+ );
}
const rowsPromise = stmtStep.query(hranaStmt);
rowsPromise.catch(() => undefined); // silence Node warning
@@ -145,7 +162,8 @@ export abstract class HranaTransaction implements Transaction {
try {
if (this.#started === undefined) {
// If the transaction hasn't started yet, start it now
- this.#started = stream.run(transactionModeToBegin(this.#mode))
+ this.#started = stream
+ .run(transactionModeToBegin(this.#mode))
.then(() => undefined);
try {
await this.#started;
@@ -180,8 +198,9 @@ export abstract class HranaTransaction implements Transaction {
}
// Pipeline the ROLLBACK statement and the stream close.
- const promise = stream.run("ROLLBACK")
- .catch(e => { throw mapHranaError(e); });
+ const promise = stream.run("ROLLBACK").catch((e) => {
+ throw mapHranaError(e);
+ });
stream.closeGracefully();
await promise;
@@ -214,8 +233,9 @@ export abstract class HranaTransaction implements Transaction {
return;
}
- const promise = stream.run("COMMIT")
- .catch(e => { throw mapHranaError(e); });
+ const promise = stream.run("COMMIT").catch((e) => {
+ throw mapHranaError(e);
+ });
stream.closeGracefully();
await promise;
@@ -238,10 +258,11 @@ export async function executeHranaBatch(
let lastStep = beginStep;
const stmtPromises = hranaStmts.map((hranaStmt) => {
- const stmtStep = batch.step()
- .condition(hrana.BatchCond.ok(lastStep));
+ const stmtStep = batch.step().condition(hrana.BatchCond.ok(lastStep));
if (version >= 3) {
- stmtStep.condition(hrana.BatchCond.not(hrana.BatchCond.isAutocommit(batch)));
+ stmtStep.condition(
+ hrana.BatchCond.not(hrana.BatchCond.isAutocommit(batch)),
+ );
}
const stmtPromise = stmtStep.query(hranaStmt);
@@ -249,16 +270,18 @@ export async function executeHranaBatch(
return stmtPromise;
});
- const commitStep = batch.step()
- .condition(hrana.BatchCond.ok(lastStep));
+ const commitStep = batch.step().condition(hrana.BatchCond.ok(lastStep));
if (version >= 3) {
- commitStep.condition(hrana.BatchCond.not(hrana.BatchCond.isAutocommit(batch)));
+ commitStep.condition(
+ hrana.BatchCond.not(hrana.BatchCond.isAutocommit(batch)),
+ );
}
const commitPromise = commitStep.run("COMMIT");
- const rollbackStep = batch.step()
+ const rollbackStep = batch
+ .step()
.condition(hrana.BatchCond.not(hrana.BatchCond.ok(commitStep)));
- rollbackStep.run("ROLLBACK").catch(_ => undefined);
+ rollbackStep.run("ROLLBACK").catch((_) => undefined);
await batch.execute();
@@ -297,13 +320,21 @@ export function stmtToHrana(stmt: InStatement): hrana.Stmt {
}
export function resultSetFromHrana(hranaRows: hrana.RowsResult): ResultSet {
- const columns = hranaRows.columnNames.map(c => c ?? "");
- const columnTypes = hranaRows.columnDecltypes.map(c => c ?? "");
+ const columns = hranaRows.columnNames.map((c) => c ?? "");
+ const columnTypes = hranaRows.columnDecltypes.map((c) => c ?? "");
const rows = hranaRows.rows;
const rowsAffected = hranaRows.affectedRowCount;
- const lastInsertRowid = hranaRows.lastInsertRowid !== undefined
- ? hranaRows.lastInsertRowid : undefined;
- return new ResultSetImpl(columns, columnTypes, rows, rowsAffected, lastInsertRowid);
+ const lastInsertRowid =
+ hranaRows.lastInsertRowid !== undefined
+ ? hranaRows.lastInsertRowid
+ : undefined;
+ return new ResultSetImpl(
+ columns,
+ columnTypes,
+ rows,
+ rowsAffected,
+ lastInsertRowid,
+ );
}
export function mapHranaError(e: unknown): unknown {
@@ -320,8 +351,9 @@ function mapHranaErrorCode(e: hrana.ClientError): string {
} else if (e instanceof hrana.ProtoError) {
return "HRANA_PROTO_ERROR";
} else if (e instanceof hrana.ClosedError) {
- return e.cause instanceof hrana.ClientError
- ? mapHranaErrorCode(e.cause) : "HRANA_CLOSED_ERROR";
+ return e.cause instanceof hrana.ClientError
+ ? mapHranaErrorCode(e.cause)
+ : "HRANA_CLOSED_ERROR";
} else if (e instanceof hrana.WebSocketError) {
return "HRANA_WEBSOCKET_ERROR";
} else if (e instanceof hrana.HttpServerError) {
diff --git a/packages/libsql-client/src/http.ts b/packages/libsql-client/src/http.ts
index 425812d2..1cf64a57 100644
--- a/packages/libsql-client/src/http.ts
+++ b/packages/libsql-client/src/http.ts
@@ -1,13 +1,21 @@
import * as hrana from "@libsql/hrana-client";
import type { Config, Client } from "@libsql/core/api";
-import type { InStatement, ResultSet, Transaction, IntMode } from "@libsql/core/api";
+import type {
+ InStatement,
+ ResultSet,
+ Transaction,
+ IntMode,
+} from "@libsql/core/api";
import { TransactionMode, LibsqlError } from "@libsql/core/api";
import type { ExpandedConfig } from "@libsql/core/config";
import { expandConfig } from "@libsql/core/config";
import {
- HranaTransaction, executeHranaBatch,
- stmtToHrana, resultSetFromHrana, mapHranaError,
+ HranaTransaction,
+ executeHranaBatch,
+ stmtToHrana,
+ resultSetFromHrana,
+ mapHranaError,
} from "./hrana.js";
import { SqlCache } from "./sql_cache.js";
import { encodeBaseUrl } from "@libsql/core/uri";
@@ -30,13 +38,22 @@ export function _createClient(config: ExpandedConfig): Client {
}
if (config.encryptionKey !== undefined) {
- throw new LibsqlError("Encryption key is not supported by the remote client.", "ENCRYPTION_KEY_NOT_SUPPORTED");
+ throw new LibsqlError(
+ "Encryption key is not supported by the remote client.",
+ "ENCRYPTION_KEY_NOT_SUPPORTED",
+ );
}
if (config.scheme === "http" && config.tls) {
- throw new LibsqlError(`A "http:" URL cannot opt into TLS by using ?tls=1`, "URL_INVALID");
+ throw new LibsqlError(
+ `A "http:" URL cannot opt into TLS by using ?tls=1`,
+ "URL_INVALID",
+ );
} else if (config.scheme === "https" && !config.tls) {
- throw new LibsqlError(`A "https:" URL cannot opt out of TLS by using ?tls=0`, "URL_INVALID");
+ throw new LibsqlError(
+ `A "https:" URL cannot opt out of TLS by using ?tls=0`,
+ "URL_INVALID",
+ );
}
const url = encodeBaseUrl(config.scheme, config.authority, config.path);
@@ -81,7 +98,10 @@ export class HttpClient implements Client {
}
}
- async batch(stmts: Array, mode: TransactionMode = "deferred"): Promise> {
+ async batch(
+ stmts: Array,
+ mode: TransactionMode = "deferred",
+ ): Promise> {
try {
const hranaStmts = stmts.map(stmtToHrana);
const version = await this.#client.getVersion();
@@ -101,7 +121,12 @@ export class HttpClient implements Client {
// 2. cursor request
// 3. pipeline request to close the stream
const batch = stream.batch(false);
- resultsPromise = executeHranaBatch(mode, version, batch, hranaStmts);
+ resultsPromise = executeHranaBatch(
+ mode,
+ version,
+ batch,
+ hranaStmts,
+ );
} finally {
stream.closeGracefully();
}
@@ -112,10 +137,16 @@ export class HttpClient implements Client {
}
}
- async transaction(mode: TransactionMode = "write"): Promise {
+ async transaction(
+ mode: TransactionMode = "write",
+ ): Promise {
try {
const version = await this.#client.getVersion();
- return new HttpTransaction(this.#client.openStream(), mode, version);
+ return new HttpTransaction(
+ this.#client.openStream(),
+ mode,
+ version,
+ );
} catch (e) {
throw mapHranaError(e);
}
@@ -140,7 +171,10 @@ export class HttpClient implements Client {
}
sync(): Promise {
- throw new LibsqlError("sync not supported in http mode", "SYNC_NOT_SUPPORTED");
+ throw new LibsqlError(
+ "sync not supported in http mode",
+ "SYNC_NOT_SUPPORTED",
+ );
}
close(): void {
@@ -157,7 +191,11 @@ export class HttpTransaction extends HranaTransaction implements Transaction {
#sqlCache: SqlCache;
/** @private */
- constructor(stream: hrana.HttpStream, mode: TransactionMode, version: hrana.ProtocolVersion) {
+ constructor(
+ stream: hrana.HttpStream,
+ mode: TransactionMode,
+ version: hrana.ProtocolVersion,
+ ) {
super(mode, version);
this.#stream = stream;
this.#sqlCache = new SqlCache(stream, sqlCacheCapacity);
diff --git a/packages/libsql-client/src/sqlite3.ts b/packages/libsql-client/src/sqlite3.ts
index f5d23936..8a9f35d3 100644
--- a/packages/libsql-client/src/sqlite3.ts
+++ b/packages/libsql-client/src/sqlite3.ts
@@ -2,13 +2,25 @@ import Database from "libsql";
import { Buffer } from "node:buffer";
import type {
- Config, IntMode, Client, Transaction, TransactionMode,
- ResultSet, Row, Value, InValue, InStatement,
+ Config,
+ IntMode,
+ Client,
+ Transaction,
+ TransactionMode,
+ ResultSet,
+ Row,
+ Value,
+ InValue,
+ InStatement,
} from "@libsql/core/api";
import { LibsqlError } from "@libsql/core/api";
import type { ExpandedConfig } from "@libsql/core/config";
import { expandConfig } from "@libsql/core/config";
-import { supportedUrlLink, transactionModeToBegin, ResultSetImpl } from "@libsql/core/util";
+import {
+ supportedUrlLink,
+ transactionModeToBegin,
+ ResultSetImpl,
+} from "@libsql/core/util";
export * from "@libsql/core/api";
@@ -43,7 +55,10 @@ export function _createClient(config: ExpandedConfig): Client {
throw new LibsqlError("File URL cannot have a port", "URL_INVALID");
}
if (authority.userinfo !== undefined) {
- throw new LibsqlError("File URL cannot have username and password", "URL_INVALID");
+ throw new LibsqlError(
+ "File URL cannot have username and password",
+ "URL_INVALID",
+ );
}
}
@@ -57,7 +72,11 @@ export function _createClient(config: ExpandedConfig): Client {
const db = new Database(path, options);
- executeStmt(db, "SELECT 1 AS checkThatTheDatabaseCanBeOpened", config.intMode);
+ executeStmt(
+ db,
+ "SELECT 1 AS checkThatTheDatabaseCanBeOpened",
+ config.intMode,
+ );
return new Sqlite3Client(path, options, db, config.intMode);
}
@@ -71,7 +90,12 @@ export class Sqlite3Client implements Client {
protocol: "file";
/** @private */
- constructor(path: string, options: Database.Options, db: Database.Database, intMode: IntMode) {
+ constructor(
+ path: string,
+ options: Database.Options,
+ db: Database.Database,
+ intMode: IntMode,
+ ) {
this.#path = path;
this.#options = options;
this.#db = db;
@@ -85,18 +109,24 @@ export class Sqlite3Client implements Client {
return executeStmt(this.#getDb(), stmt, this.#intMode);
}
- async batch(stmts: Array, mode: TransactionMode = "deferred"): Promise> {
+ async batch(
+ stmts: Array,
+ mode: TransactionMode = "deferred",
+ ): Promise> {
this.#checkNotClosed();
const db = this.#getDb();
try {
executeStmt(db, transactionModeToBegin(mode), this.#intMode);
const resultSets = stmts.map((stmt) => {
if (!db.inTransaction) {
- throw new LibsqlError("The transaction has been rolled back", "TRANSACTION_CLOSED");
+ throw new LibsqlError(
+ "The transaction has been rolled back",
+ "TRANSACTION_CLOSED",
+ );
}
return executeStmt(db, stmt, this.#intMode);
});
- executeStmt(db, "COMMIT", this.#intMode)
+ executeStmt(db, "COMMIT", this.#intMode);
return resultSets;
} finally {
if (db.inTransaction) {
@@ -124,7 +154,6 @@ export class Sqlite3Client implements Client {
}
}
-
async sync(): Promise {
this.#checkNotClosed();
await this.#getDb().sync();
@@ -204,12 +233,19 @@ export class Sqlite3Transaction implements Transaction {
#checkNotClosed(): void {
if (this.closed) {
- throw new LibsqlError("The transaction is closed", "TRANSACTION_CLOSED");
+ throw new LibsqlError(
+ "The transaction is closed",
+ "TRANSACTION_CLOSED",
+ );
}
}
}
-function executeStmt(db: Database.Database, stmt: InStatement, intMode: IntMode): ResultSet {
+function executeStmt(
+ db: Database.Database,
+ stmt: InStatement,
+ intMode: IntMode,
+): ResultSet {
let sql: string;
let args: Array | Record;
if (typeof stmt === "string") {
@@ -222,8 +258,10 @@ function executeStmt(db: Database.Database, stmt: InStatement, intMode: IntMode)
} else {
args = {};
for (const name in stmt.args) {
- const argName = (name[0] === "@" || name[0] === "$" || name[0] === ":")
- ? name.substring(1) : name;
+ const argName =
+ name[0] === "@" || name[0] === "$" || name[0] === ":"
+ ? name.substring(1)
+ : name;
args[argName] = valueToSql(stmt.args[name], intMode);
}
}
@@ -242,15 +280,25 @@ function executeStmt(db: Database.Database, stmt: InStatement, intMode: IntMode)
}
if (returnsData) {
- const columns = Array.from(sqlStmt.columns().map(col => col.name));
- const columnTypes = Array.from(sqlStmt.columns().map(col => col.type ?? ""));
+ const columns = Array.from(
+ sqlStmt.columns().map((col) => col.name),
+ );
+ const columnTypes = Array.from(
+ sqlStmt.columns().map((col) => col.type ?? ""),
+ );
const rows = sqlStmt.all(args).map((sqlRow) => {
return rowFromSql(sqlRow as Array, columns, intMode);
});
// TODO: can we get this info from better-sqlite3?
const rowsAffected = 0;
const lastInsertRowid = undefined;
- return new ResultSetImpl(columns, columnTypes, rows, rowsAffected, lastInsertRowid);
+ return new ResultSetImpl(
+ columns,
+ columnTypes,
+ rows,
+ rowsAffected,
+ lastInsertRowid,
+ );
} else {
const info = sqlStmt.run(args);
const rowsAffected = info.changes;
@@ -262,7 +310,11 @@ function executeStmt(db: Database.Database, stmt: InStatement, intMode: IntMode)
}
}
-function rowFromSql(sqlRow: Array, columns: Array, intMode: IntMode): Row {
+function rowFromSql(
+ sqlRow: Array,
+ columns: Array,
+ intMode: IntMode,
+): Row {
const row = {};
// make sure that the "length" property is not enumerable
Object.defineProperty(row, "length", { value: sqlRow.length });
@@ -272,7 +324,12 @@ function rowFromSql(sqlRow: Array, columns: Array, intMode: Int
const column = columns[i];
if (!Object.hasOwn(row, column)) {
- Object.defineProperty(row, column, { value, enumerable: true, configurable: true, writable: true });
+ Object.defineProperty(row, column, {
+ value,
+ enumerable: true,
+ configurable: true,
+ writable: true,
+ });
}
}
return row as Row;
@@ -283,14 +340,14 @@ function valueFromSql(sqlValue: unknown, intMode: IntMode): Value {
if (intMode === "number") {
if (sqlValue < minSafeBigint || sqlValue > maxSafeBigint) {
throw new RangeError(
- "Received integer which cannot be safely represented as a JavaScript number"
+ "Received integer which cannot be safely represented as a JavaScript number",
);
}
return Number(sqlValue);
} else if (intMode === "bigint") {
return sqlValue;
} else if (intMode === "string") {
- return ""+sqlValue;
+ return "" + sqlValue;
} else {
throw new Error("Invalid value for IntMode");
}
@@ -306,31 +363,35 @@ const maxSafeBigint = 9007199254740991n;
function valueToSql(value: InValue, intMode: IntMode): unknown {
if (typeof value === "number") {
if (!Number.isFinite(value)) {
- throw new RangeError("Only finite numbers (not Infinity or NaN) can be passed as arguments");
+ throw new RangeError(
+ "Only finite numbers (not Infinity or NaN) can be passed as arguments",
+ );
}
return value;
} else if (typeof value === "bigint") {
if (value < minInteger || value > maxInteger) {
throw new RangeError(
- "bigint is too large to be represented as a 64-bit integer and passed as argument"
+ "bigint is too large to be represented as a 64-bit integer and passed as argument",
);
}
return value;
} else if (typeof value === "boolean") {
- switch(intMode) {
- case "bigint":
- return value ? 1n : 0n;
- case "string":
- return value ? "1" : "0";
- default:
- return value ? 1 : 0;
- }
+ switch (intMode) {
+ case "bigint":
+ return value ? 1n : 0n;
+ case "string":
+ return value ? "1" : "0";
+ default:
+ return value ? 1 : 0;
+ }
} else if (value instanceof ArrayBuffer) {
return Buffer.from(value);
} else if (value instanceof Date) {
return value.valueOf();
} else if (value === undefined) {
- throw new TypeError("undefined cannot be passed as argument to the database");
+ throw new TypeError(
+ "undefined cannot be passed as argument to the database",
+ );
} else {
return value;
}
diff --git a/packages/libsql-client/src/ws.ts b/packages/libsql-client/src/ws.ts
index 5b88c4d3..8b5f0c00 100644
--- a/packages/libsql-client/src/ws.ts
+++ b/packages/libsql-client/src/ws.ts
@@ -1,12 +1,22 @@
import * as hrana from "@libsql/hrana-client";
-import type { Config, IntMode, Client, Transaction, ResultSet, InStatement } from "@libsql/core/api";
+import type {
+ Config,
+ IntMode,
+ Client,
+ Transaction,
+ ResultSet,
+ InStatement,
+} from "@libsql/core/api";
import { TransactionMode, LibsqlError } from "@libsql/core/api";
import type { ExpandedConfig } from "@libsql/core/config";
import { expandConfig } from "@libsql/core/config";
import {
- HranaTransaction, executeHranaBatch,
- stmtToHrana, resultSetFromHrana, mapHranaError,
+ HranaTransaction,
+ executeHranaBatch,
+ stmtToHrana,
+ resultSetFromHrana,
+ mapHranaError,
} from "./hrana.js";
import { SqlCache } from "./sql_cache.js";
import { encodeBaseUrl } from "@libsql/core/uri";
@@ -29,13 +39,22 @@ export function _createClient(config: ExpandedConfig): WsClient {
}
if (config.encryptionKey !== undefined) {
- throw new LibsqlError("Encryption key is not supported by the remote client.", "ENCRYPTION_KEY_NOT_SUPPORTED");
+ throw new LibsqlError(
+ "Encryption key is not supported by the remote client.",
+ "ENCRYPTION_KEY_NOT_SUPPORTED",
+ );
}
if (config.scheme === "ws" && config.tls) {
- throw new LibsqlError(`A "ws:" URL cannot opt into TLS by using ?tls=1`, "URL_INVALID");
+ throw new LibsqlError(
+ `A "ws:" URL cannot opt into TLS by using ?tls=1`,
+ "URL_INVALID",
+ );
} else if (config.scheme === "wss" && !config.tls) {
- throw new LibsqlError(`A "wss:" URL cannot opt out of TLS by using ?tls=0`, "URL_INVALID");
+ throw new LibsqlError(
+ `A "wss:" URL cannot opt out of TLS by using ?tls=0`,
+ "URL_INVALID",
+ );
}
const url = encodeBaseUrl(config.scheme, config.authority, config.path);
@@ -46,7 +65,11 @@ export function _createClient(config: ExpandedConfig): WsClient {
} catch (e) {
if (e instanceof hrana.WebSocketUnsupportedError) {
const suggestedScheme = config.scheme === "wss" ? "https" : "http";
- const suggestedUrl = encodeBaseUrl(suggestedScheme, config.authority, config.path);
+ const suggestedUrl = encodeBaseUrl(
+ suggestedScheme,
+ config.authority,
+ config.path,
+ );
throw new LibsqlError(
"This environment does not support WebSockets, please switch to the HTTP client by using " +
`a "${suggestedScheme}:" URL (${JSON.stringify(suggestedUrl)}). ` +
@@ -70,7 +93,7 @@ interface ConnState {
useSqlCache: boolean | undefined;
// The cache of SQL texts stored on the server. Initially has capacity 0, but it is set to
// `sqlCacheCapacity` when `useSqlCache` is set to `true`.
- sqlCache: SqlCache,
+ sqlCache: SqlCache;
// The time when the connection was opened.
openTime: Date;
// Set of all `StreamState`-s that were opened from this connection. We can safely close the connection
@@ -83,7 +106,7 @@ interface StreamState {
stream: hrana.WsStream;
}
-const maxConnAgeMillis = 60*1000;
+const maxConnAgeMillis = 60 * 1000;
const sqlCacheCapacity = 100;
export class WsClient implements Client {
@@ -99,7 +122,12 @@ export class WsClient implements Client {
protocol: "ws";
/** @private */
- constructor(client: hrana.WsClient, url: URL, authToken: string | undefined, intMode: IntMode) {
+ constructor(
+ client: hrana.WsClient,
+ url: URL,
+ authToken: string | undefined,
+ intMode: IntMode,
+ ) {
this.#url = url;
this.#authToken = authToken;
this.#intMode = intMode;
@@ -128,7 +156,10 @@ export class WsClient implements Client {
}
}
- async batch(stmts: Array, mode: TransactionMode = "deferred"): Promise> {
+ async batch(
+ stmts: Array,
+ mode: TransactionMode = "deferred",
+ ): Promise> {
const streamState = await this.#openStream();
try {
const hranaStmts = stmts.map(stmtToHrana);
@@ -138,7 +169,12 @@ export class WsClient implements Client {
// network roundtrip.
streamState.conn.sqlCache.apply(hranaStmts);
const batch = streamState.stream.batch(version >= 3);
- const resultsPromise = executeHranaBatch(mode, version, batch, hranaStmts);
+ const resultsPromise = executeHranaBatch(
+ mode,
+ version,
+ batch,
+ hranaStmts,
+ );
return await resultsPromise;
} catch (e) {
@@ -189,7 +225,10 @@ export class WsClient implements Client {
const now = new Date();
const ageMillis = now.valueOf() - this.#connState.openTime.valueOf();
- if (ageMillis > maxConnAgeMillis && this.#futureConnState === undefined) {
+ if (
+ ageMillis > maxConnAgeMillis &&
+ this.#futureConnState === undefined
+ ) {
// The existing connection is too old, let's open a new one.
const futureConnState = this.#openConn();
this.#futureConnState = futureConnState;
@@ -247,7 +286,8 @@ export class WsClient implements Client {
// this does not increase latency, because any messages that we would send on the WebSocket before
// the handshake would be queued until the handshake is completed anyway.
if (connState.useSqlCache === undefined) {
- connState.useSqlCache = await connState.client.getVersion() >= 2;
+ connState.useSqlCache =
+ (await connState.client.getVersion()) >= 2;
if (connState.useSqlCache) {
connState.sqlCache.capacity = sqlCacheCapacity;
}
@@ -255,7 +295,7 @@ export class WsClient implements Client {
const stream = connState.client.openStream();
stream.intMode = this.#intMode;
- const streamState = {conn: connState, stream};
+ const streamState = { conn: connState, stream };
connState.streamStates.add(streamState);
return streamState;
} catch (e) {
@@ -283,7 +323,10 @@ export class WsClient implements Client {
const connState = streamState.conn;
connState.streamStates.delete(streamState);
- if (connState.streamStates.size === 0 && connState !== this.#connState) {
+ if (
+ connState.streamStates.size === 0 &&
+ connState !== this.#connState
+ ) {
// We are not using this connection anymore and this is the last stream that was using it, so we
// must close it now.
connState.client.close();
@@ -301,7 +344,12 @@ export class WsTransaction extends HranaTransaction implements Transaction {
#streamState: StreamState;
/** @private */
- constructor(client: WsClient, state: StreamState, mode: TransactionMode, version: hrana.ProtocolVersion) {
+ constructor(
+ client: WsClient,
+ state: StreamState,
+ mode: TransactionMode,
+ version: hrana.ProtocolVersion,
+ ) {
super(mode, version);
this.#client = client;
this.#streamState = state;
diff --git a/packages/libsql-client/tsconfig.build-cjs.json b/packages/libsql-client/tsconfig.build-cjs.json
index 857027a0..8feb91c5 100644
--- a/packages/libsql-client/tsconfig.build-cjs.json
+++ b/packages/libsql-client/tsconfig.build-cjs.json
@@ -6,4 +6,3 @@
"outDir": "./lib-cjs/"
}
}
-
diff --git a/packages/libsql-client/tsconfig.build-esm.json b/packages/libsql-client/tsconfig.build-esm.json
index 9a01705b..2ba1706d 100644
--- a/packages/libsql-client/tsconfig.build-esm.json
+++ b/packages/libsql-client/tsconfig.build-esm.json
@@ -6,4 +6,3 @@
"outDir": "./lib-esm/"
}
}
-
diff --git a/packages/libsql-core/jest.config.js b/packages/libsql-core/jest.config.js
index 65716e3c..044a5b86 100644
--- a/packages/libsql-core/jest.config.js
+++ b/packages/libsql-core/jest.config.js
@@ -1,7 +1,7 @@
export default {
preset: "ts-jest/presets/default-esm",
moduleNameMapper: {
- '^(\\.{1,2}/.*)\\.js$': '$1',
+ "^(\\.{1,2}/.*)\\.js$": "$1",
},
testMatch: ["**/__tests__/*.test.[jt]s"],
-}
+};
diff --git a/packages/libsql-core/src/api.ts b/packages/libsql-core/src/api.ts
index 1424bc7f..6278fc03 100644
--- a/packages/libsql-core/src/api.ts
+++ b/packages/libsql-core/src/api.ts
@@ -88,7 +88,7 @@ export interface Client {
*
* The `mode` parameter selects the transaction mode for the batch; please see {@link TransactionMode} for
* details. The default transaction mode is `"deferred"`.
- *
+ *
* If any of the statements in the batch fails with an error, the batch is aborted, the transaction is
* rolled back and the returned promise is rejected.
*
@@ -114,7 +114,10 @@ export interface Client {
* ], "write");
* ```
*/
- batch(stmts: Array, mode?: TransactionMode): Promise>;
+ batch(
+ stmts: Array,
+ mode?: TransactionMode,
+ ): Promise>;
/** Start an interactive transaction.
*
@@ -367,7 +370,7 @@ export interface ResultSet {
* returned.
*/
columnTypes: Array;
-
+
/** Rows produced by the statement. */
rows: Array;
@@ -419,20 +422,11 @@ export interface Row {
[name: string]: Value;
}
-export type Value =
- | null
- | string
- | number
- | bigint
- | ArrayBuffer
+export type Value = null | string | number | bigint | ArrayBuffer;
-export type InValue =
- | Value
- | boolean
- | Uint8Array
- | Date
+export type InValue = Value | boolean | Uint8Array | Date;
-export type InStatement = { sql: string, args: InArgs } | string;
+export type InStatement = { sql: string; args: InArgs } | string;
export type InArgs = Array | Record;
/** Error thrown by the client. */
@@ -441,14 +435,19 @@ export class LibsqlError extends Error {
code: string;
/** Raw numeric error code */
rawCode?: number;
-
- constructor(message: string, code: string, rawCode?: number, cause?: Error) {
+
+ constructor(
+ message: string,
+ code: string,
+ rawCode?: number,
+ cause?: Error,
+ ) {
if (code !== undefined) {
message = `${code}: ${message}`;
}
super(message, { cause });
this.code = code;
- this.rawCode = rawCode
+ this.rawCode = rawCode;
this.name = "LibsqlError";
}
}
diff --git a/packages/libsql-core/src/config.ts b/packages/libsql-core/src/config.ts
index a1d63745..2eb42672 100644
--- a/packages/libsql-core/src/config.ts
+++ b/packages/libsql-core/src/config.ts
@@ -19,11 +19,16 @@ export interface ExpandedConfig {
export type ExpandedScheme = "wss" | "ws" | "https" | "http" | "file";
-export function expandConfig(config: Config, preferHttp: boolean): ExpandedConfig {
+export function expandConfig(
+ config: Config,
+ preferHttp: boolean,
+): ExpandedConfig {
if (typeof config !== "object") {
// produce a reasonable error message in the common case where users type
// `createClient("libsql://...")` instead of `createClient({url: "libsql://..."})`
- throw new TypeError(`Expected client configuration as object, got ${typeof config}`);
+ throw new TypeError(
+ `Expected client configuration as object, got ${typeof config}`,
+ );
}
let tls: boolean | undefined = config.tls;
@@ -31,32 +36,31 @@ export function expandConfig(config: Config, preferHttp: boolean): ExpandedConfi
let encryptionKey = config.encryptionKey;
let syncUrl = config.syncUrl;
let syncInterval = config.syncInterval;
- const intMode = ""+(config.intMode ?? "number");
+ const intMode = "" + (config.intMode ?? "number");
if (intMode !== "number" && intMode !== "bigint" && intMode !== "string") {
throw new TypeError(
`Invalid value for intMode, expected "number", "bigint" or "string", \
- got ${JSON.stringify(intMode)}`
+ got ${JSON.stringify(intMode)}`,
);
}
-
- if(config.url === ':memory:') {
- return {
- path: ':memory:',
- scheme: 'file',
- syncUrl,
- syncInterval,
- intMode,
- fetch: config.fetch,
- tls: false,
- authToken: undefined,
- encryptionKey: undefined,
- authority: undefined,
- };
+ if (config.url === ":memory:") {
+ return {
+ path: ":memory:",
+ scheme: "file",
+ syncUrl,
+ syncInterval,
+ intMode,
+ fetch: config.fetch,
+ tls: false,
+ authToken: undefined,
+ encryptionKey: undefined,
+ authority: undefined,
+ };
}
const uri = parseUri(config.url);
- for (const {key, value} of uri.query?.pairs ?? []) {
+ for (const { key, value } of uri.query?.pairs ?? []) {
if (key === "authToken") {
authToken = value ? value : undefined;
} else if (key === "tls") {
@@ -73,7 +77,7 @@ export function expandConfig(config: Config, preferHttp: boolean): ExpandedConfi
}
} else {
throw new LibsqlError(
- `Unknown URL query parameter ${JSON.stringify(key)}`,
+ `Unknown URL query parameter ${JSON.stringify(key)}`,
"URL_PARAM_NOT_SUPPORTED",
);
}
@@ -96,7 +100,11 @@ export function expandConfig(config: Config, preferHttp: boolean): ExpandedConfi
} else if (uriScheme === "http" || uriScheme === "ws") {
scheme = uriScheme;
tls ??= false;
- } else if (uriScheme === "https" || uriScheme === "wss" || uriScheme === "file") {
+ } else if (
+ uriScheme === "https" ||
+ uriScheme === "wss" ||
+ uriScheme === "file"
+ ) {
scheme = uriScheme;
} else {
throw new LibsqlError(
diff --git a/packages/libsql-core/src/uri.ts b/packages/libsql-core/src/uri.ts
index 3117f2f4..abe46337 100644
--- a/packages/libsql-core/src/uri.ts
+++ b/packages/libsql-core/src/uri.ts
@@ -30,7 +30,7 @@ export interface Userinfo {
}
export interface Query {
- pairs: Array,
+ pairs: Array;
}
export interface KeyValue {
@@ -41,53 +41,70 @@ export interface KeyValue {
export function parseUri(text: string): Uri {
const match = URI_RE.exec(text);
if (match === null) {
- throw new LibsqlError("The URL is not in a valid format", "URL_INVALID");
+ throw new LibsqlError(
+ "The URL is not in a valid format",
+ "URL_INVALID",
+ );
}
const groups = match.groups!;
const scheme = groups["scheme"]!;
- const authority = groups["authority"] !== undefined
- ? parseAuthority(groups["authority"]) : undefined;
+ const authority =
+ groups["authority"] !== undefined
+ ? parseAuthority(groups["authority"])
+ : undefined;
const path = percentDecode(groups["path"]!);
- const query = groups["query"] !== undefined
- ? parseQuery(groups["query"]) : undefined;
- const fragment = groups["fragment"] !== undefined
- ? percentDecode(groups["fragment"]) : undefined;
- return {scheme, authority, path, query, fragment};
+ const query =
+ groups["query"] !== undefined ? parseQuery(groups["query"]) : undefined;
+ const fragment =
+ groups["fragment"] !== undefined
+ ? percentDecode(groups["fragment"])
+ : undefined;
+ return { scheme, authority, path, query, fragment };
}
const URI_RE = (() => {
- const SCHEME = '(?[A-Za-z][A-Za-z.+-]*)';
- const AUTHORITY = '(?[^/?#]*)';
- const PATH = '(?[^?#]*)';
- const QUERY = '(?[^#]*)';
- const FRAGMENT = '(?.*)'
- return new RegExp(`^${SCHEME}:(//${AUTHORITY})?${PATH}(\\?${QUERY})?(#${FRAGMENT})?$`, "su");
+ const SCHEME = "(?[A-Za-z][A-Za-z.+-]*)";
+ const AUTHORITY = "(?[^/?#]*)";
+ const PATH = "(?[^?#]*)";
+ const QUERY = "(?[^#]*)";
+ const FRAGMENT = "(?.*)";
+ return new RegExp(
+ `^${SCHEME}:(//${AUTHORITY})?${PATH}(\\?${QUERY})?(#${FRAGMENT})?$`,
+ "su",
+ );
})();
function parseAuthority(text: string): Authority {
const match = AUTHORITY_RE.exec(text);
if (match === null) {
- throw new LibsqlError("The authority part of the URL is not in a valid format", "URL_INVALID");
+ throw new LibsqlError(
+ "The authority part of the URL is not in a valid format",
+ "URL_INVALID",
+ );
}
const groups = match.groups!;
const host = percentDecode(groups["host_br"] ?? groups["host"]);
- const port = groups["port"]
- ? parseInt(groups["port"], 10)
- : undefined;
- const userinfo = groups["username"] !== undefined
- ? {
- username: percentDecode(groups["username"]),
- password: groups["password"] !== undefined
- ? percentDecode(groups["password"]) : undefined,
- }
- : undefined;
- return {host, port, userinfo};
+ const port = groups["port"] ? parseInt(groups["port"], 10) : undefined;
+ const userinfo =
+ groups["username"] !== undefined
+ ? {
+ username: percentDecode(groups["username"]),
+ password:
+ groups["password"] !== undefined
+ ? percentDecode(groups["password"])
+ : undefined,
+ }
+ : undefined;
+ return { host, port, userinfo };
}
const AUTHORITY_RE = (() => {
- return new RegExp(`^((?[^:]*)(:(?.*))?@)?((?[^:\\[\\]]*)|(\\[(?[^\\[\\]]*)\\]))(:(?[0-9]*))?$`, "su");
+ return new RegExp(
+ `^((?[^:]*)(:(?.*))?@)?((?[^:\\[\\]]*)|(\\[(?[^\\[\\]]*)\\]))(:(?[0-9]*))?$`,
+ "su",
+ );
})();
// Query string is parsed as application/x-www-form-urlencoded according to the Web URL standard:
@@ -108,7 +125,7 @@ function parseQuery(text: string): Query {
value = "";
} else {
key = sequence.substring(0, splitIdx);
- value = sequence.substring(splitIdx+1);
+ value = sequence.substring(splitIdx + 1);
}
pairs.push({
@@ -116,7 +133,7 @@ function parseQuery(text: string): Query {
value: percentDecode(value.replaceAll("+", " ")),
});
}
- return {pairs};
+ return { pairs };
}
function percentDecode(text: string): string {
@@ -124,13 +141,22 @@ function percentDecode(text: string): string {
return decodeURIComponent(text);
} catch (e) {
if (e instanceof URIError) {
- throw new LibsqlError(`URL component has invalid percent encoding: ${e}`, "URL_INVALID", undefined, e);
+ throw new LibsqlError(
+ `URL component has invalid percent encoding: ${e}`,
+ "URL_INVALID",
+ undefined,
+ e,
+ );
}
throw e;
}
}
-export function encodeBaseUrl(scheme: string, authority: Authority | undefined, path: string): URL {
+export function encodeBaseUrl(
+ scheme: string,
+ authority: Authority | undefined,
+ path: string,
+): URL {
if (authority === undefined) {
throw new LibsqlError(
`URL with scheme ${JSON.stringify(scheme + ":")} requires authority (the "//" part)`,
@@ -167,7 +193,9 @@ function encodeUserinfo(userinfo: Userinfo | undefined): string {
}
const usernameText = encodeURIComponent(userinfo.username);
- const passwordText = userinfo.password !== undefined
- ? `:${encodeURIComponent(userinfo.password)}` : "";
+ const passwordText =
+ userinfo.password !== undefined
+ ? `:${encodeURIComponent(userinfo.password)}`
+ : "";
return `${usernameText}${passwordText}@`;
}
diff --git a/packages/libsql-core/src/util.ts b/packages/libsql-core/src/util.ts
index 285cc86c..6d5bdbb6 100644
--- a/packages/libsql-core/src/util.ts
+++ b/packages/libsql-core/src/util.ts
@@ -1,7 +1,15 @@
import { Base64 } from "js-base64";
-import { ResultSet, Row, Value, TransactionMode, InStatement, LibsqlError } from "./api";
+import {
+ ResultSet,
+ Row,
+ Value,
+ TransactionMode,
+ InStatement,
+ LibsqlError,
+} from "./api";
-export const supportedUrlLink = "https://github.com/libsql/libsql-client-ts#supported-urls";
+export const supportedUrlLink =
+ "https://github.com/libsql/libsql-client-ts#supported-urls";
export function transactionModeToBegin(mode: TransactionMode): string {
if (mode === "write") {
@@ -11,7 +19,9 @@ export function transactionModeToBegin(mode: TransactionMode): string {
} else if (mode === "deferred") {
return "BEGIN DEFERRED";
} else {
- throw RangeError('Unknown transaction mode, supported values are "write", "read" and "deferred"');
+ throw RangeError(
+ 'Unknown transaction mode, supported values are "write", "read" and "deferred"',
+ );
}
}
@@ -38,11 +48,14 @@ export class ResultSetImpl implements ResultSet {
toJSON(): any {
return {
- "columns": this.columns,
- "columnTypes": this.columnTypes,
- "rows": this.rows.map(rowToJson),
- "rowsAffected": this.rowsAffected,
- "lastInsertRowid": this.lastInsertRowid !== undefined ? ""+this.lastInsertRowid : null,
+ columns: this.columns,
+ columnTypes: this.columnTypes,
+ rows: this.rows.map(rowToJson),
+ rowsAffected: this.rowsAffected,
+ lastInsertRowid:
+ this.lastInsertRowid !== undefined
+ ? "" + this.lastInsertRowid
+ : null,
};
}
}
@@ -53,7 +66,7 @@ function rowToJson(row: Row): unknown {
function valueToJson(value: Value): unknown {
if (typeof value === "bigint") {
- return ""+value;
+ return "" + value;
} else if (value instanceof ArrayBuffer) {
return Base64.fromUint8Array(new Uint8Array(value));
} else {
diff --git a/packages/libsql-core/tsconfig.build-cjs.json b/packages/libsql-core/tsconfig.build-cjs.json
index 857027a0..8feb91c5 100644
--- a/packages/libsql-core/tsconfig.build-cjs.json
+++ b/packages/libsql-core/tsconfig.build-cjs.json
@@ -6,4 +6,3 @@
"outDir": "./lib-cjs/"
}
}
-
diff --git a/packages/libsql-core/tsconfig.build-esm.json b/packages/libsql-core/tsconfig.build-esm.json
index 9a01705b..2ba1706d 100644
--- a/packages/libsql-core/tsconfig.build-esm.json
+++ b/packages/libsql-core/tsconfig.build-esm.json
@@ -6,4 +6,3 @@
"outDir": "./lib-esm/"
}
}
-