rado 0.3.4 → 0.3.6

package/dist/deno/lib/SqlError.js

@@ -1,11 +0,0 @@
-// 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

@@ -1,108 +0,0 @@
-// 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

@@ -1,70 +0,0 @@
-// 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

@@ -1,150 +0,0 @@
-// 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

@@ -1,47 +0,0 @@
-// 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

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

package/dist/deno/util/Callable.js

@@ -1,15 +0,0 @@
-// 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/sqlite/index.d.ts

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

package/dist/sqlite/index.js

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

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

@@ -1,49 +0,0 @@
-// 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

@@ -1,66 +0,0 @@
-// 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
-};

package/dist/src/driver/sqlite3.js

@@ -1,87 +0,0 @@
-// src/driver/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 new Promise((resolve, reject) => {
-      this.stmt.all(params, (err, rows) => {
-        if (err)
-          reject(err);
-        else
-          resolve(rows);
-      });
-    });
-  }
-  run(params) {
-    return new Promise((resolve, reject) => {
-      this.stmt.run(params, function(err) {
-        if (err)
-          reject(err);
-        else
-          resolve({ rowsAffected: this.changes });
-      });
-    });
-  }
-  get(params) {
-    return new Promise((resolve, reject) => {
-      this.stmt.get(params, (err, row) => {
-        if (err)
-          reject(err);
-        else
-          resolve(row);
-      });
-    });
-  }
-  execute(params) {
-    return new Promise((resolve, reject) => {
-      this.stmt.run(params, (err) => {
-        if (err)
-          reject(err);
-        else
-          resolve();
-      });
-    });
-  }
-};
-var Sqlite3Driver = class extends Driver.Async {
-  constructor(db) {
-    super(new SqliteFormatter());
-    this.db = db;
-    this.tableData = this.prepare(SqliteSchema.tableData);
-    this.indexData = this.prepare(SqliteSchema.indexData);
-  }
-  lock;
-  tableData;
-  indexData;
-  async executeQuery(query, stmt, params) {
-    await this.lock;
-    return super.executeQuery(query, stmt, params);
-  }
-  prepareStatement(stmt) {
-    return new PreparedStatement(this.db.prepare(stmt.sql));
-  }
-  async schemaInstructions(tableName) {
-    const columnData = await this.tableData(tableName);
-    const indexData = await this.indexData(tableName);
-    return SqliteSchema.createInstructions(columnData, indexData);
-  }
-  isolate() {
-    const connection = new Sqlite3Driver(this.db);
-    let release, trigger = new Promise((resolve) => {
-      release = async () => resolve();
-    });
-    this.lock = Promise.resolve(this.lock).then(() => trigger);
-    return [connection, release];
-  }
-};
-function connect(db) {
-  return new Sqlite3Driver(db);
-}
-export {
-  Sqlite3Driver,
-  connect
-};

package/dist/src/index.js

@@ -1,24 +0,0 @@
-// src/index.ts
-export * from "./lib/Column.js";
-export * from "./lib/Cursor.js";
-export * from "./lib/Driver.js";
-export * from "./lib/Expr.js";
-export * from "./lib/Fields.js";
-export * from "./lib/Formatter.js";
-import { Functions } from "./lib/Functions.js";
-export * from "./lib/Id.js";
-export * from "./lib/Index.js";
-export * from "./lib/Ops.js";
-export * from "./lib/OrderBy.js";
-export * from "./lib/Param.js";
-export * from "./lib/Query.js";
-export * from "./lib/Sanitizer.js";
-export * from "./lib/Schema.js";
-export * from "./lib/Selection.js";
-export * from "./lib/Statement.js";
-export * from "./lib/Table.js";
-export * from "./lib/Target.js";
-export * from "./lib/Update.js";
-export {
-  Functions
-};

package/dist/src/lib/Column.js

@@ -1,63 +0,0 @@
-// src/lib/Column.ts
-import { ExprData } from "./Expr.js";
-var ColumnType = /* @__PURE__ */ ((ColumnType2) => {
-  ColumnType2["String"] = "String";
-  ColumnType2["Integer"] = "Integer";
-  ColumnType2["Number"] = "Number";
-  ColumnType2["Boolean"] = "Boolean";
-  ColumnType2["Json"] = "Json";
-  return ColumnType2;
-})(ColumnType || {});
-var Column = class {
-  constructor(data) {
-    this.data = data;
-  }
-  name(name) {
-    return new Column({ ...this.data, name });
-  }
-  nullable() {
-    return new Column({ ...this.data, nullable: true });
-  }
-  autoIncrement() {
-    return new Column({ ...this.data, autoIncrement: true });
-  }
-  primaryKey() {
-    return new Column({ ...this.data, primaryKey: true });
-  }
-  references(column2) {
-    return new Column({ ...this.data, references: ExprData.create(column2) });
-  }
-  unique() {
-    return new Column({ ...this.data, unique: true });
-  }
-  defaultValue(value) {
-    return new Column({ ...this.data, defaultValue: ExprData.create(value) });
-  }
-};
-((Column2) => {
-})(Column || (Column = {}));
-var column = {
-  string() {
-    return new Column({ type: "String" /* String */ });
-  },
-  integer() {
-    return new Column({ type: "Integer" /* Integer */ });
-  },
-  number() {
-    return new Column({ type: "Number" /* Number */ });
-  },
-  boolean() {
-    return new Column({ type: "Boolean" /* Boolean */ });
-  },
-  object() {
-    return new Column({ type: "Json" /* Json */ });
-  },
-  array() {
-    return new Column({ type: "Json" /* Json */ });
-  }
-};
-export {
-  Column,
-  ColumnType,
-  column
-};