rado 0.3.2 → 0.3.4

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/bun-sqlite.js

@@ -1,5 +1,4 @@
-import { QueryData } from "../define/Query.js";
-import { SelectFirst } from "../define/query/Select.js";
+import { QueryData, SelectFirst } from "../define/Query.js";
 import { Driver } from "../lib/Driver.js";
 import { SqliteFormatter } from "../sqlite/SqliteFormatter.js";
 import { SqliteSchema } from "../sqlite/SqliteSchema.js";

package/dist/index.d.ts

@@ -14,14 +14,6 @@ export * from './define/Sql.js';
 export * from './define/Table.js';
 export * from './define/Target.js';
 export * from './define/VirtualTable.js';
-export * from './define/query/Batch.js';
-export * from './define/query/CreateTable.js';
-export * from './define/query/Delete.js';
-export * from './define/query/Insert.js';
-export * from './define/query/Select.js';
-export * from './define/query/TableSelect.js';
-export * from './define/query/Union.js';
-export * from './define/query/Update.js';
 export type { Driver, DriverOptions } from './lib/Driver.js';
 export type { FormatContext, Formatter } from './lib/Formatter.js';
 export type { Sanitizer } from './lib/Sanitizer.js';

package/dist/index.js

@@ -11,12 +11,4 @@ export * from "./define/Sql.js";
 export * from "./define/Table.js";
 export * from "./define/Target.js";
 export * from "./define/VirtualTable.js";
-export * from "./define/query/Batch.js";
-export * from "./define/query/CreateTable.js";
-export * from "./define/query/Delete.js";
-export * from "./define/query/Insert.js";
-export * from "./define/query/Select.js";
-export * from "./define/query/TableSelect.js";
-export * from "./define/query/Union.js";
-export * from "./define/query/Update.js";
 export * from "./lib/SqlError.js";

package/dist/lib/Driver.d.ts

@@ -1,8 +1,7 @@
 import { Expr } from '../define/Expr.js';
-import { Query, QueryData } from '../define/Query.js';
+import { Query, QueryData, Select } from '../define/Query.js';
 import { SchemaInstructions } from '../define/Schema.js';
 import { Table } from '../define/Table.js';
-import { Select } from '../define/query/Select.js';
 import { Callable } from '../util/Callable.js';
 import { Formatter } from './Formatter.js';
 import { Statement } from './Statement.js';

package/dist/lib/Formatter.js

@@ -201,10 +201,24 @@ class Formatter {
     stmt.add("CREATE TABLE");
     if (query.ifNotExists)
       stmt.add("IF NOT EXISTS");
-    stmt.addIdentifier(query.table.name);
-    for (const column of stmt.call(Object.values(query.table.columns))) {
+    stmt.addIdentifier(query.table.name).space();
+    stmt.openParenthesis();
+    for (const column of stmt.separate(Object.values(query.table.columns))) {
       this.formatColumn(ctx, column);
     }
+    const meta = query.table.meta();
+    if (meta.primaryKey) {
+      stmt.raw(",").newline().raw("PRIMARY KEY").space();
+      for (const expr of stmt.call(meta.primaryKey))
+        switch (expr.type) {
+          case ExprType.Field:
+            stmt.identifier(expr.field);
+            continue;
+          default:
+            throw new Error(`Cannot format index of type ${expr.type}`);
+        }
+    }
+    stmt.closeParenthesis();
     return stmt;
   }
   formatCreateIndex(ctx, query) {
@@ -593,7 +607,7 @@ class Formatter {
       case UnOpType.IsNull:
         return this.formatExprValue(ctx, expr.expr).add("IS NULL");
       case UnOpType.Not:
-        stmt.raw("NOT").openParenthesis();
+        stmt.raw("NOT").space().openParenthesis();
         this.formatExprValue(ctx, expr.expr);
         return stmt.closeParenthesis();
     }

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
+};