rado 0.4.4 → 0.4.6

package/dist/deno/lib/SqlError.js

@@ -0,0 +1,11 @@
+// src/lib/SqlError.ts
+var SqlError = class extends Error {
+  constructor(cause, sql) {
+    super(`${sql}
+\u2502
+\u2514\u2500\u2500\u2500\u2500 ${cause}`, { cause });
+  }
+};
+export {
+  SqlError
+};

package/dist/deno/lib/Statement.js

@@ -0,0 +1,108 @@
+// src/lib/Statement.ts
+import { ParamData, ParamType } from "../define/Param.ts";
+var SEPARATE = ", ";
+var WHITESPACE = " ";
+var NEWLINE = "\n";
+var INSERT_PARAM = "?";
+var Statement = class {
+  constructor(sanitizer, options = {}) {
+    this.sanitizer = sanitizer;
+    this.options = options;
+  }
+  sql = "";
+  paramData = [];
+  currentIndent = "";
+  space() {
+    if (this.sql === "")
+      return this;
+    return this.raw(WHITESPACE);
+  }
+  add(addition) {
+    if (!addition)
+      return this;
+    return this.space().raw(addition);
+  }
+  addLine(addition) {
+    if (!addition)
+      return this;
+    return this.newline().raw(addition);
+  }
+  indent() {
+    this.currentIndent = this.currentIndent + "  ";
+    return this;
+  }
+  dedent() {
+    this.currentIndent = this.currentIndent.slice(0, -2);
+    return this;
+  }
+  newline() {
+    if (this.options.skipNewlines)
+      return this;
+    return this.raw(NEWLINE + this.currentIndent);
+  }
+  identifier(name) {
+    return this.raw(this.sanitizer.escapeIdentifier(name));
+  }
+  addIdentifier(name) {
+    return this.space().identifier(name);
+  }
+  value(value) {
+    this.paramData.push(ParamData.Value(value));
+    return this.raw(INSERT_PARAM);
+  }
+  addValue(value) {
+    return this.space().value(value);
+  }
+  param(data) {
+    this.paramData.push(data);
+    return this.raw(INSERT_PARAM);
+  }
+  addParam(data) {
+    return this.space().param(data);
+  }
+  raw(query) {
+    if (!query)
+      return this;
+    this.sql += query;
+    return this;
+  }
+  openParenthesis() {
+    return this.raw("(").indent().newline();
+  }
+  closeParenthesis() {
+    return this.dedent().newline().raw(")");
+  }
+  *call(parts, separator = SEPARATE) {
+    if (parts.length === 0)
+      return this.raw("()");
+    this.openParenthesis();
+    yield* this.separate(parts, separator);
+    this.closeParenthesis();
+  }
+  *separate(parts, separator = SEPARATE) {
+    for (let i = 0; i < parts.length; i++) {
+      if (i > 0)
+        this.raw(separator).newline();
+      yield parts[i];
+    }
+  }
+  isEmpty() {
+    return this.sql === "";
+  }
+  params(input) {
+    return this.paramData.map((param) => {
+      if (param.type === ParamType.Named) {
+        if (input && param.name in input)
+          return this.sanitizer.formatParamValue(input[param.name]);
+        throw new TypeError(`Missing parameter ${param.name}`);
+      }
+      return this.sanitizer.formatParamValue(param.value);
+    });
+  }
+  toString() {
+    return this.sql;
+  }
+};
+export {
+  Statement
+};

package/dist/deno/sqlite/SqliteFormatter.js

@@ -0,0 +1,70 @@
+// src/sqlite/SqliteFormatter.ts
+import { ExprType } from "../define/Expr.ts";
+import { Formatter } from "../lib/Formatter.ts";
+var BACKTICK = "`";
+var ESCAPE_BACKTICK = "``";
+var SINGLE_QUOTE = "'";
+var ESCAPE_SINGLE_QUOTE = "''";
+var MATCH_BACKTICK = /`/g;
+var MATCH_SINGLE_QUOTE = /'/g;
+var SqliteFormatter = class extends Formatter {
+  formatParamValue(paramValue) {
+    if (paramValue === null || paramValue === void 0)
+      return null;
+    if (typeof paramValue === "boolean")
+      return paramValue ? 1 : 0;
+    if (typeof paramValue === "number")
+      return paramValue;
+    if (typeof paramValue === "string")
+      return paramValue;
+    return JSON.stringify(paramValue);
+  }
+  escapeValue(value) {
+    if (value === null || value === void 0)
+      return "NULL";
+    if (typeof value === "boolean")
+      return value ? "1" : "0";
+    if (typeof value === "number")
+      return String(value);
+    if (typeof value === "string")
+      return this.escapeString(value);
+    return "json(" + this.escapeString(JSON.stringify(value)) + ")";
+  }
+  escapeIdentifier(input) {
+    return BACKTICK + input.replace(MATCH_BACKTICK, ESCAPE_BACKTICK) + BACKTICK;
+  }
+  escapeString(input) {
+    return SINGLE_QUOTE + input.replace(MATCH_SINGLE_QUOTE, ESCAPE_SINGLE_QUOTE) + SINGLE_QUOTE;
+  }
+  formatAccess(ctx, mkSubject, field) {
+    const { stmt, formatAsJson } = ctx;
+    mkSubject();
+    stmt.raw(formatAsJson ? "->" : "->>");
+    return this.formatString(ctx, `$.${field}`);
+  }
+  formatExpr(ctx, expr) {
+    const { stmt } = ctx;
+    switch (expr.type) {
+      case ExprType.Call:
+        switch (expr.method) {
+          case "match":
+            const [from, query] = expr.params;
+            this.formatExprValue({ ...ctx, tableAsExpr: true }, from);
+            stmt.raw(" MATCH ");
+            this.formatExprValue(ctx, query);
+            return stmt;
+          case "highlight":
+          case "snippet":
+            stmt.identifier(expr.method);
+            for (const param of stmt.call(expr.params))
+              this.formatExprValue({ ...ctx, tableAsExpr: true }, param);
+            return stmt;
+        }
+      default:
+        return super.formatExpr(ctx, expr);
+    }
+  }
+};
+export {
+  SqliteFormatter
+};

package/dist/deno/sqlite/SqliteFunctions.js

@@ -0,0 +1,150 @@
+// src/sqlite/SqliteFunctions.ts
+import { Functions } from "../define/Functions.ts";
+var SqliteFunctions = Functions;
+var {
+  count,
+  iif,
+  exists,
+  match,
+  highlight,
+  snippet,
+  cast,
+  abs,
+  changes,
+  char,
+  coalesce,
+  ifnull,
+  instr,
+  last_insert_rowid,
+  length,
+  likelihood,
+  likely,
+  lower,
+  ltrim,
+  max,
+  min,
+  nullif,
+  prnumberf,
+  quote,
+  random,
+  replace,
+  round,
+  rtrim,
+  sign,
+  soundex,
+  sqlite_version,
+  substr,
+  total_changes,
+  trim,
+  unicode,
+  unlikely,
+  upper,
+  avg,
+  group_concat,
+  sum,
+  acos,
+  acosh,
+  asin,
+  asinh,
+  atan,
+  atan2,
+  atanh,
+  ceil,
+  cos,
+  cosh,
+  degrees,
+  exp,
+  floor,
+  ln,
+  log,
+  log2,
+  mod,
+  pi,
+  pow,
+  radians,
+  sin,
+  sinh,
+  sqrt,
+  tan,
+  tanh,
+  trunc,
+  date,
+  time,
+  datetime,
+  julianday,
+  strftime
+} = SqliteFunctions;
+export {
+  SqliteFunctions,
+  abs,
+  acos,
+  acosh,
+  asin,
+  asinh,
+  atan,
+  atan2,
+  atanh,
+  avg,
+  cast,
+  ceil,
+  changes,
+  char,
+  coalesce,
+  cos,
+  cosh,
+  count,
+  date,
+  datetime,
+  degrees,
+  exists,
+  exp,
+  floor,
+  group_concat,
+  highlight,
+  ifnull,
+  iif,
+  instr,
+  julianday,
+  last_insert_rowid,
+  length,
+  likelihood,
+  likely,
+  ln,
+  log,
+  log2,
+  lower,
+  ltrim,
+  match,
+  max,
+  min,
+  mod,
+  nullif,
+  pi,
+  pow,
+  prnumberf,
+  quote,
+  radians,
+  random,
+  replace,
+  round,
+  rtrim,
+  sign,
+  sin,
+  sinh,
+  snippet,
+  soundex,
+  sqlite_version,
+  sqrt,
+  strftime,
+  substr,
+  sum,
+  tan,
+  tanh,
+  time,
+  total_changes,
+  trim,
+  trunc,
+  unicode,
+  unlikely,
+  upper
+};

package/dist/deno/sqlite/SqliteSchema.js

@@ -0,0 +1,47 @@
+// src/sqlite/SqliteSchema.ts
+import { Cursor } from "../define/Cursor.ts";
+import { Statement } from "../lib/Statement.ts";
+import { SqliteFormatter } from "./SqliteFormatter.ts";
+var SqliteSchema;
+((SqliteSchema2) => {
+  const formatter = new SqliteFormatter();
+  function tableData(tableName) {
+    return Cursor.all`select * from pragma_table_info(${tableName}) order by cid`;
+  }
+  SqliteSchema2.tableData = tableData;
+  function indexData(tableName) {
+    return Cursor.all`select * from sqlite_master where type='index' and tbl_name=${tableName}`;
+  }
+  SqliteSchema2.indexData = indexData;
+  function createInstructions(columnData, indexData2) {
+    if (columnData.length === 0 && indexData2.length === 0)
+      return void 0;
+    const columns = columnData.map(columnInstruction);
+    const indexes = indexData2.map(indexInstruction).filter((row) => row[1]);
+    return {
+      columns: Object.fromEntries(columns),
+      indexes: Object.fromEntries(indexes)
+    };
+  }
+  SqliteSchema2.createInstructions = createInstructions;
+  function columnInstruction(column) {
+    const stmt = new Statement(formatter);
+    stmt.identifier(column.name).add(column.type);
+    if (column.pk === 1)
+      stmt.add("PRIMARY KEY");
+    if (column.notnull === 1)
+      stmt.add("NOT NULL");
+    if (column.dflt_value !== null) {
+      stmt.add("DEFAULT").space().openParenthesis().raw(column.dflt_value).closeParenthesis();
+    }
+    return [column.name, stmt.sql];
+  }
+  SqliteSchema2.columnInstruction = columnInstruction;
+  function indexInstruction(index) {
+    return [index.name, index.sql];
+  }
+  SqliteSchema2.indexInstruction = indexInstruction;
+})(SqliteSchema || (SqliteSchema = {}));
+export {
+  SqliteSchema
+};

package/dist/deno/sqlite.js

@@ -0,0 +1,3 @@
+// src/sqlite.ts
+export * from "./sqlite/SqliteFormatter.ts";
+export * from "./sqlite/SqliteFunctions.ts";

package/dist/deno/util/Callable.js

@@ -0,0 +1,15 @@
+// src/util/Callable.ts
+function callable(target, call) {
+  return new Proxy(call, {
+    set(_, prop, value) {
+      target[prop] = value;
+      return true;
+    },
+    get(_, prop) {
+      return target[prop];
+    }
+  });
+}
+export {
+  callable
+};

package/dist/driver/d1.d.ts

@@ -13,7 +13,10 @@ export declare class D1Driver extends Driver.Async {
     executeQuery(query: QueryData, stmt?: Driver.Async.PreparedStatement, params?: any[] | undefined): Promise<unknown>;
     prepareStatement(stmt: Statement): Driver.Async.PreparedStatement;
     schemaInstructions(tableName: string): Promise<SchemaInstructions | undefined>;
-    isolate(): [connection: Driver.Async, release: () => Promise<void>];
+    isolate(): Promise<[
+        connection: Driver.Async,
+        release: () => Promise<void>
+    ]>;
     close(): Promise<void>;
 }
 export declare function connect(db: D1Database, options?: DriverOptions): D1Driver;

package/dist/driver/d1.js

@@ -48,12 +48,14 @@ class D1Driver extends Driver.Async {
     const indexData = await this.indexData(tableName);
     return SqliteSchema.createInstructions(columnData, indexData);
   }
-  isolate() {
+  async isolate() {
+    const currentLock = this.lock;
     const connection = new D1Driver(this.db);
     let release, trigger = new Promise((resolve) => {
       release = async () => resolve();
     });
-    this.lock = Promise.resolve(this.lock).then(() => trigger);
+    this.lock = Promise.resolve(currentLock).then(() => trigger);
+    await currentLock;
     return [connection, release];
   }
   async close() {

package/dist/driver/sqlite3.d.ts

@@ -13,7 +13,10 @@ export declare class Sqlite3Driver extends Driver.Async {
     executeQuery(query: QueryData, stmt?: Driver.Async.PreparedStatement, params?: any[] | undefined): Promise<unknown>;
     prepareStatement(stmt: Statement): Driver.Async.PreparedStatement;
     schemaInstructions(tableName: string): Promise<SchemaInstructions | undefined>;
-    isolate(): [connection: Driver.Async, release: () => Promise<void>];
+    isolate(): Promise<[
+        connection: Driver.Async,
+        release: () => Promise<void>
+    ]>;
     close(): Promise<void>;
 }
 export declare function connect(db: Database, options?: DriverOptions): Sqlite3Driver;

package/dist/driver/sqlite3.js

@@ -101,12 +101,14 @@ class Sqlite3Driver extends Driver.Async {
     const indexData = await this.indexData(tableName);
     return SqliteSchema.createInstructions(columnData, indexData);
   }
-  isolate() {
+  async isolate() {
+    const currentLock = this.lock;
     const connection = new Sqlite3Driver(this.db);
     let release, trigger = new Promise((resolve) => {
       release = async () => resolve();
     });
-    this.lock = Promise.resolve(this.lock).then(() => trigger);
+    this.lock = Promise.resolve(currentLock).then(() => trigger);
+    await currentLock;
     return [connection, release];
   }
   async close() {

package/dist/lib/Driver.d.ts

@@ -59,7 +59,10 @@ declare abstract class AsyncDriver extends DriverBase {
     transactionId: number;
     constructor(formatter: Formatter, options?: DriverOptions);
     abstract close(): Promise<void>;
-    abstract isolate(): [connection: AsyncDriver, release: () => Promise<void>];
+    abstract isolate(): Promise<[
+        connection: AsyncDriver,
+        release: () => Promise<void>
+    ]>;
     abstract prepareStatement(stmt: Statement, discardAfter: boolean): AsyncPreparedStatement;
     abstract schemaInstructions(tableName: string): Promise<SchemaInstructions | undefined>;
     createStatement(stmt: Statement, discardAfter: boolean): AsyncPreparedStatement;
@@ -78,7 +81,10 @@ declare class SyncWrapper extends AsyncDriver {
     executeQuery(query: QueryData, stmt?: AsyncPreparedStatement, params?: Array<any>): Promise<unknown>;
     prepareStatement(stmt: Statement, discardAfter: boolean): AsyncPreparedStatement;
     schemaInstructions(tableName: string): Promise<SchemaInstructions | undefined>;
-    isolate(): [connection: AsyncDriver, release: () => Promise<void>];
+    isolate(): Promise<[
+        connection: AsyncDriver,
+        release: () => Promise<void>
+    ]>;
 }
 interface AsyncPreparedStatement {
     run(params: Array<any>): Promise<{

package/dist/lib/Driver.js

@@ -308,7 +308,7 @@ class AsyncDriver extends DriverBase {
   }
   async transaction(run) {
     const id = `t${this.transactionId++}`;
-    const [connection, release] = this.isolate();
+    const [connection, release] = await this.isolate();
     await connection.executeQuery(
       new QueryData.Transaction({ op: QueryData.TransactionOperation.Begin, id })
     );
@@ -327,7 +327,8 @@ class AsyncDriver extends DriverBase {
           op: QueryData.TransactionOperation.Rollback,
           id
         })
-      );
+      ).catch(() => {
+      });
       throw e;
     } finally {
       await release();
@@ -376,12 +377,14 @@ class SyncWrapper extends AsyncDriver {
   async schemaInstructions(tableName) {
     return this.sync.schemaInstructions(tableName);
   }
-  isolate() {
+  async isolate() {
+    const currentLock = this.lock;
     const connection = new SyncWrapper(this.sync);
     let release, trigger = new Promise((resolve) => {
       release = async () => resolve();
     });
-    this.lock = Promise.resolve(this.lock).then(() => trigger);
+    this.lock = Promise.resolve(currentLock).then(() => trigger);
+    await currentLock;
     return [connection, release];
   }
 }

package/dist/sqlite/index.d.ts

@@ -0,0 +1,2 @@
+export * from './SqliteFormatter';
+export * from './SqliteFunctions';

package/dist/sqlite/index.js

@@ -0,0 +1,3 @@
+// src/sqlite/index.ts
+export * from "./SqliteFormatter.js";
+export * from "./SqliteFunctions.js";

package/dist/src/driver/better-sqlite3.js

@@ -0,0 +1,49 @@
+// src/driver/better-sqlite3.ts
+import { Driver } from "../lib/Driver.js";
+import { SqliteFormatter } from "../sqlite/SqliteFormatter.js";
+import { SqliteSchema } from "../sqlite/SqliteSchema.js";
+var PreparedStatement = class {
+  constructor(stmt) {
+    this.stmt = stmt;
+  }
+  all(params = []) {
+    return this.stmt.all(...params);
+  }
+  run(params = []) {
+    return { rowsAffected: this.stmt.run(...params).changes };
+  }
+  get(params = []) {
+    return this.stmt.get(...params);
+  }
+  execute(params = []) {
+    this.stmt.run(...params);
+  }
+};
+var BetterSqlite3Driver = class extends Driver.Sync {
+  constructor(db) {
+    super(new SqliteFormatter());
+    this.db = db;
+    this.tableData = this.prepare(SqliteSchema.tableData);
+    this.indexData = this.prepare(SqliteSchema.indexData);
+  }
+  tableData;
+  indexData;
+  prepareStatement(stmt) {
+    return new PreparedStatement(this.db.prepare(stmt.sql));
+  }
+  schemaInstructions(tableName) {
+    const columnData = this.tableData(tableName);
+    const indexData = this.indexData(tableName);
+    return SqliteSchema.createInstructions(columnData, indexData);
+  }
+  export() {
+    return this.db.serialize();
+  }
+};
+function connect(db) {
+  return new BetterSqlite3Driver(db);
+}
+export {
+  BetterSqlite3Driver,
+  connect
+};

package/dist/src/driver/sql.js.js

@@ -0,0 +1,66 @@
+// src/driver/sql.js.ts
+import { Driver } from "../lib/Driver.js";
+import { SqliteFormatter } from "../sqlite/SqliteFormatter.js";
+import { SqliteSchema } from "../sqlite/SqliteSchema.js";
+var PreparedStatement = class {
+  constructor(db, stmt, discardAfter) {
+    this.db = db;
+    this.stmt = stmt;
+    this.discardAfter = discardAfter;
+  }
+  all(params) {
+    this.stmt.bind(params);
+    const res = [];
+    while (this.stmt.step())
+      res.push(this.stmt.getAsObject());
+    if (this.discardAfter)
+      this.stmt.free();
+    return res;
+  }
+  run(params) {
+    this.stmt.run(params);
+    if (this.discardAfter)
+      this.stmt.free();
+    return { rowsAffected: this.db.getRowsModified() };
+  }
+  get(params) {
+    return this.all(params)[0];
+  }
+  execute(params) {
+    this.stmt.run(params);
+    if (this.discardAfter)
+      this.stmt.free();
+  }
+};
+var SqlJsDriver = class extends Driver.Sync {
+  constructor(db) {
+    super(new SqliteFormatter());
+    this.db = db;
+    this.tableData = this.prepare(SqliteSchema.tableData);
+    this.indexData = this.prepare(SqliteSchema.indexData);
+  }
+  tableData;
+  indexData;
+  prepareStatement(stmt, discardAfter) {
+    return new PreparedStatement(
+      this.db,
+      this.db.prepare(stmt.sql),
+      discardAfter
+    );
+  }
+  schemaInstructions(tableName) {
+    const columnData = this.tableData(tableName);
+    const indexData = this.indexData(tableName);
+    return SqliteSchema.createInstructions(columnData, indexData);
+  }
+  export() {
+    return this.db.export();
+  }
+};
+function connect(db) {
+  return new SqlJsDriver(db);
+}
+export {
+  SqlJsDriver,
+  connect
+};