chore: lint

Author: pi0

.prettierignore

@@ -1,6 +1,7 @@
-connectors
-integrations
-src/_connectors.ts
-dist
-node_modules
-.output
+/connectors
+/integrations
+/src/_connectors.ts
+/dist
+/node_modules
+/.output
+pnpm-lock.yaml

src/connectors/better-sqlite3.ts

@@ -2,7 +2,7 @@ import { resolve, dirname } from "node:path";
 import { mkdirSync } from "node:fs";
 import Database from "better-sqlite3";
 import type { Connector } from "db0";
-import type { Statement as RawStatement } from 'better-sqlite3'
+import type { Statement as RawStatement } from "better-sqlite3";
 import { BoundableStatement } from "./_internal/statement";
 
 export interface ConnectorOptions {
@@ -11,7 +11,9 @@ export interface ConnectorOptions {
   name?: string;
 }
 
-export default function sqliteConnector(opts: ConnectorOptions): Connector<Database.Database> {
+export default function sqliteConnector(
+  opts: ConnectorOptions,
+): Connector<Database.Database> {
   let _db: Database.Database;
   const getDB = () => {
     if (_db) {
@@ -34,22 +36,22 @@ export default function sqliteConnector(opts: ConnectorOptions): Connector<Datab
     name: "sqlite",
     dialect: "sqlite",
     getInstance: () => getDB(),
-    exec: sql => getDB().exec(sql),
-    prepare: sql => new StatementWrapper(() => getDB().prepare(sql))
+    exec: (sql) => getDB().exec(sql),
+    prepare: (sql) => new StatementWrapper(() => getDB().prepare(sql)),
   };
 }
 
 class StatementWrapper extends BoundableStatement<() => RawStatement> {
   async all(...params) {
-    return this._statement().all(...params)
+    return this._statement().all(...params);
   }
 
   async run(...params) {
-    const res = this._statement().run(...params)
-    return { success: res.changes > 0, ...res }
+    const res = this._statement().run(...params);
+    return { success: res.changes > 0, ...res };
   }
 
   async get(...params) {
-    return this._statement().get(...params)
+    return this._statement().get(...params);
   }
 }

src/connectors/bun-sqlite.ts

@@ -10,7 +10,9 @@ export interface ConnectorOptions {
   name?: string;
 }
 
-export default function bunSqliteConnector(opts: ConnectorOptions): Connector<Database> {
+export default function bunSqliteConnector(
+  opts: ConnectorOptions,
+): Connector<Database> {
   let _db: Database;
   const getDB = () => {
     if (_db) {
@@ -33,8 +35,8 @@ export default function bunSqliteConnector(opts: ConnectorOptions): Connector<Da
     name: "sqlite",
     dialect: "sqlite",
     getInstance: () => getDB(),
-    exec: sql => getDB().exec(sql),
-    prepare: sql => new StatementWrapper(getDB().prepare(sql))
+    exec: (sql) => getDB().exec(sql),
+    prepare: (sql) => new StatementWrapper(getDB().prepare(sql)),
   };
 }
 

src/connectors/cloudflare-d1.ts

@@ -1,43 +1,52 @@
-import type { D1Database, D1PreparedStatement as RawStatement  } from '@cloudflare/workers-types'
+import type {
+  D1Database,
+  D1PreparedStatement as RawStatement,
+} from "@cloudflare/workers-types";
 import type { Connector } from "db0";
 import { BoundableStatement } from "./_internal/statement";
 
 export interface ConnectorOptions {
   bindingName?: string;
 }
 
-export default function cloudflareD1Connector(options: ConnectorOptions): Connector<D1Database> {
+export default function cloudflareD1Connector(
+  options: ConnectorOptions,
+): Connector<D1Database> {
   const getDB = () => {
     // TODO: Remove legacy __cf_env__ support in next major version
-    const binding: D1Database = globalThis.__env__?.[options.bindingName] || globalThis.__cf_env__?.[options.bindingName];
+    const binding: D1Database =
+      globalThis.__env__?.[options.bindingName] ||
+      globalThis.__cf_env__?.[options.bindingName];
     if (!binding) {
-      throw new Error(`[db0] [d1] binding \`${options.bindingName}\` not found`);
+      throw new Error(
+        `[db0] [d1] binding \`${options.bindingName}\` not found`,
+      );
     }
     return binding;
-  }
+  };
 
   return {
     name: "cloudflare-d1",
     dialect: "sqlite",
     getInstance: () => getDB(),
     exec: (sql) => getDB().exec(sql),
-    prepare: sql => new StatementWrapper(getDB().prepare(sql))
+    prepare: (sql) => new StatementWrapper(getDB().prepare(sql)),
   };
 }
 
 class StatementWrapper extends BoundableStatement<RawStatement> {
   async all(...params) {
-    const res = await this._statement.bind(...params).all()
-    return res.results
+    const res = await this._statement.bind(...params).all();
+    return res.results;
   }
 
   async run(...params) {
-    const res = await this._statement.bind(...params).run()
-    return res
+    const res = await this._statement.bind(...params).run();
+    return res;
   }
 
   async get(...params) {
-    const res = await this._statement.bind(...params).first()
-    return res
+    const res = await this._statement.bind(...params).first();
+    return res;
   }
 }

src/connectors/libsql/core.ts

@@ -9,14 +9,16 @@ export type ConnectorOptions = {
 
 type InternalQuery = (sql: InStatement) => Promise<any>;
 
-export default function libSqlCoreConnector(opts: ConnectorOptions): Connector<Client> {
+export default function libSqlCoreConnector(
+  opts: ConnectorOptions,
+): Connector<Client> {
   const query: InternalQuery = (sql) => opts.getClient().execute(sql);
 
   return {
     name: opts.name || "libsql-core",
     dialect: "libsql",
     getInstance: async () => opts.getClient(),
-    exec: sql => query(sql),
+    exec: (sql) => query(sql),
     prepare: (sql) => new StatementWrapper(sql, query),
   };
 }
@@ -32,19 +34,19 @@ class StatementWrapper extends BoundableStatement<void> {
   }
 
   async all(...params) {
-    const res = await this.#query({ sql: this.#sql, args: params })
+    const res = await this.#query({ sql: this.#sql, args: params });
     return res.rows;
   }
 
   async run(...params) {
-   const res = await this.#query({ sql: this.#sql, args: params })
+    const res = await this.#query({ sql: this.#sql, args: params });
     return {
-      ...res
-    }
+      ...res,
+    };
   }
 
   async get(...params) {
-    const res = await this.#query({ sql: this.#sql, args: params })
+    const res = await this.#query({ sql: this.#sql, args: params });
     return res.rows[0];
   }
 }

src/connectors/libsql/http.ts

@@ -3,10 +3,11 @@ import type { Connector } from "db0";
 import { createClient } from "@libsql/client/http";
 import libSqlCore from "./core";
 
-
 export type ConnectorOptions = Config;
 
-export default function libSqlConnector(opts: ConnectorOptions): Connector<Client> {
+export default function libSqlConnector(
+  opts: ConnectorOptions,
+): Connector<Client> {
   let _client;
   const getClient = () => {
     if (!_client) {

src/connectors/libsql/node.ts

@@ -5,7 +5,9 @@ import libSqlCore from "./core";
 
 export type ConnectorOptions = Config;
 
-export default function libSqlConnector(opts: ConnectorOptions): Connector<Client> {
+export default function libSqlConnector(
+  opts: ConnectorOptions,
+): Connector<Client> {
   let _client;
   const getClient = () => {
     if (!_client) {

src/connectors/libsql/web.ts

@@ -5,7 +5,9 @@ import libSqlCore from "./core";
 
 export type ConnectorOptions = Config;
 
-export default function libSqlConnector(opts: ConnectorOptions): Connector<Client> {
+export default function libSqlConnector(
+  opts: ConnectorOptions,
+): Connector<Client> {
   let _client;
   const getClient = () => {
     if (!_client) {

src/connectors/mysql2.ts

@@ -2,11 +2,16 @@ import mysql from "mysql2/promise";
 import type { Connector } from "db0";
 import { BoundableStatement } from "./_internal/statement";
 
-export type ConnectorOptions = mysql.ConnectionOptions
+export type ConnectorOptions = mysql.ConnectionOptions;
 
-type InternalQuery = (sql: string, params?: unknown[]) => Promise<mysql.QueryResult>
+type InternalQuery = (
+  sql: string,
+  params?: unknown[],
+) => Promise<mysql.QueryResult>;
 
-export default function mysqlConnector(opts: ConnectorOptions): Connector<mysql.Connection> {
+export default function mysqlConnector(
+  opts: ConnectorOptions,
+): Connector<mysql.Connection> {
   let _connection: mysql.Connection | undefined;
   const getConnection = async () => {
     if (_connection) {
@@ -15,19 +20,22 @@ export default function mysqlConnector(opts: ConnectorOptions): Connector<mysql.
 
     _connection = await mysql.createConnection({
       ...opts,
-    })
+    });
 
     return _connection;
   };
 
-  const query: InternalQuery = (sql, params) => getConnection().then((c) => c.query(sql, params)).then((res) => res[0]);
+  const query: InternalQuery = (sql, params) =>
+    getConnection()
+      .then((c) => c.query(sql, params))
+      .then((res) => res[0]);
 
   return {
     name: "mysql",
     dialect: "mysql",
     getInstance: () => getConnection(),
-    exec: sql => query(sql),
-    prepare: sql => new StatementWrapper(sql, query)
+    exec: (sql) => query(sql),
+    prepare: (sql) => new StatementWrapper(sql, query),
   };
 }
 
@@ -42,20 +50,20 @@ class StatementWrapper extends BoundableStatement<void> {
   }
 
   async all(...params) {
-    const res =  await this.#query(this.#sql, params) as mysql.RowDataPacket[]
-    return res
+    const res = (await this.#query(this.#sql, params)) as mysql.RowDataPacket[];
+    return res;
   }
 
   async run(...params) {
-    const res = await this.#query(this.#sql, params) as mysql.RowDataPacket[]
+    const res = (await this.#query(this.#sql, params)) as mysql.RowDataPacket[];
     return {
       success: true,
       ...res,
-    }
+    };
   }
 
   async get(...params) {
-    const res = await this.#query(this.#sql, params) as mysql.RowDataPacket[]
-    return res[0]
+    const res = (await this.#query(this.#sql, params)) as mysql.RowDataPacket[];
+    return res[0];
   }
 }