rado 0.3.3 → 0.3.4

package/dist/src/lib/OrderBy.js

@@ -0,0 +1,9 @@
+// src/lib/OrderBy.ts
+var OrderDirection = /* @__PURE__ */ ((OrderDirection2) => {
+  OrderDirection2["Asc"] = "Asc";
+  OrderDirection2["Desc"] = "Desc";
+  return OrderDirection2;
+})(OrderDirection || {});
+export {
+  OrderDirection
+};

package/dist/src/lib/Param.js

@@ -0,0 +1,27 @@
+// src/lib/Param.ts
+import { Expr, ExprData } from "./Expr.js";
+var ParamType = /* @__PURE__ */ ((ParamType2) => {
+  ParamType2["Value"] = "Value";
+  ParamType2["Named"] = "Named";
+  return ParamType2;
+})(ParamType || {});
+var ParamData = {
+  Value(value) {
+    return { type: "Value" /* Value */, value };
+  },
+  Named(name) {
+    return { type: "Named" /* Named */, name };
+  }
+};
+function createParams() {
+  return new Proxy({}, {
+    get(target, prop) {
+      return new Expr(ExprData.Param(ParamData.Named(prop)));
+    }
+  });
+}
+export {
+  ParamData,
+  ParamType,
+  createParams
+};

package/dist/src/lib/Query.js

@@ -0,0 +1,74 @@
+// src/lib/Query.ts
+var QueryType = /* @__PURE__ */ ((QueryType2) => {
+  QueryType2["Insert"] = "Insert";
+  QueryType2["Select"] = "Select";
+  QueryType2["Update"] = "Update";
+  QueryType2["Delete"] = "Delete";
+  QueryType2["CreateTable"] = "CreateTable";
+  QueryType2["CreateIndex"] = "CreateIndex";
+  QueryType2["DropIndex"] = "DropIndex";
+  QueryType2["AlterTable"] = "AlterTable";
+  QueryType2["Batch"] = "Batch";
+  QueryType2["Transaction"] = "Transaction";
+  QueryType2["Raw"] = "Raw";
+  return QueryType2;
+})(QueryType || {});
+var Query;
+((Query2) => {
+  function Insert(insert) {
+    return { type: "Insert" /* Insert */, ...insert };
+  }
+  Query2.Insert = Insert;
+  function Select(select) {
+    return { type: "Select" /* Select */, ...select };
+  }
+  Query2.Select = Select;
+  function Update(update) {
+    return { type: "Update" /* Update */, ...update };
+  }
+  Query2.Update = Update;
+  function Delete(del) {
+    return { type: "Delete" /* Delete */, ...del };
+  }
+  Query2.Delete = Delete;
+  function CreateTable(create) {
+    return { type: "CreateTable" /* CreateTable */, ...create };
+  }
+  Query2.CreateTable = CreateTable;
+  function CreateIndex(create) {
+    return { type: "CreateIndex" /* CreateIndex */, ...create };
+  }
+  Query2.CreateIndex = CreateIndex;
+  function DropIndex(drop) {
+    return { type: "DropIndex" /* DropIndex */, ...drop };
+  }
+  Query2.DropIndex = DropIndex;
+  function Batch(batch) {
+    return { type: "Batch" /* Batch */, ...batch };
+  }
+  Query2.Batch = Batch;
+  let TransactionOperation;
+  ((TransactionOperation2) => {
+    TransactionOperation2["Begin"] = "Begin";
+    TransactionOperation2["Commit"] = "Commit";
+    TransactionOperation2["Rollback"] = "Rollback";
+  })(TransactionOperation = Query2.TransactionOperation || (Query2.TransactionOperation = {}));
+  function Transaction(transaction) {
+    return { type: "Transaction" /* Transaction */, ...transaction };
+  }
+  Query2.Transaction = Transaction;
+  function Raw(raw) {
+    if (raw.strings.some((chunk) => chunk.includes("?")))
+      throw new TypeError("SQL injection hazard");
+    return { type: "Raw" /* Raw */, ...raw };
+  }
+  Query2.Raw = Raw;
+  function AlterTable(alter) {
+    return { type: "AlterTable" /* AlterTable */, ...alter };
+  }
+  Query2.AlterTable = AlterTable;
+})(Query || (Query = {}));
+export {
+  Query,
+  QueryType
+};

package/dist/src/lib/Schema.js

@@ -0,0 +1,67 @@
+// src/lib/Schema.ts
+import { Query } from "./Query.js";
+import { Statement } from "./Statement.js";
+var Schema;
+((Schema2) => {
+  function create(schema) {
+    const queries = [];
+    queries.push(Query.CreateTable({ table: schema, ifNotExists: true }));
+    for (const index of Object.values(schema.indexes))
+      queries.push(Query.CreateIndex({ table: schema, index, ifNotExists: true }));
+    return Query.Batch({ queries });
+  }
+  Schema2.create = create;
+  function removeLeadingWhitespace(str) {
+    return str.replace(/\n\s+/g, "\n");
+  }
+  function upgrade(formatter, local, schema) {
+    const columnNames = /* @__PURE__ */ new Set([
+      ...Object.keys(local.columns),
+      ...Object.keys(schema.columns)
+    ]);
+    const res = [];
+    for (const columnName of columnNames) {
+      const localInstruction = local.columns[columnName];
+      const schemaCol = schema.columns[columnName];
+      if (!localInstruction) {
+        res.push(Query.AlterTable({ table: schema, addColumn: schemaCol }));
+      } else if (!schemaCol) {
+        res.push(Query.AlterTable({ table: schema, dropColumn: columnName }));
+      } else {
+        const { sql: instruction } = formatter.formatColumn(
+          { stmt: new Statement(formatter) },
+          { ...schemaCol, references: void 0 }
+        );
+        if (removeLeadingWhitespace(localInstruction) !== removeLeadingWhitespace(instruction)) {
+          res.push(Query.AlterTable({ table: schema, alterColumn: schemaCol }));
+        }
+      }
+    }
+    const indexNames = /* @__PURE__ */ new Set([
+      ...Object.keys(local.indexes),
+      ...Object.keys(schema.indexes)
+    ]);
+    for (const indexName of indexNames) {
+      const localInstruction = local.indexes[indexName];
+      const schemaIndex = schema.indexes[indexName];
+      if (!localInstruction) {
+        res.push(Query.CreateIndex({ table: schema, index: schemaIndex }));
+      } else if (!schemaIndex) {
+        res.unshift(Query.DropIndex({ table: schema, name: indexName }));
+      } else {
+        const { sql: instruction } = formatter.compile(
+          Query.CreateIndex({ table: schema, index: schemaIndex })
+        );
+        if (removeLeadingWhitespace(localInstruction) !== removeLeadingWhitespace(instruction)) {
+          res.unshift(Query.DropIndex({ table: schema, name: indexName }));
+          res.push(Query.CreateIndex({ table: schema, index: schemaIndex }));
+        }
+      }
+    }
+    return res;
+  }
+  Schema2.upgrade = upgrade;
+})(Schema || (Schema = {}));
+export {
+  Schema
+};

package/dist/src/lib/Selection.js

@@ -0,0 +1,7 @@
+// src/lib/Selection.ts
+var Selection;
+((Selection2) => {
+})(Selection || (Selection = {}));
+export {
+  Selection
+};

package/dist/src/lib/Statement.js

@@ -0,0 +1,103 @@
+// src/lib/Statement.ts
+import { ParamData, ParamType } from "./Param.js";
+var SEPARATE = ", ";
+var WHITESPACE = " ";
+var NEWLINE = "\n";
+var INSERT_PARAM = "?";
+var Statement = class {
+  constructor(sanitizer, sql = "", paramData = []) {
+    this.sanitizer = sanitizer;
+    this.sql = sql;
+    this.paramData = 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().add(addition);
+  }
+  indent() {
+    this.currentIndent = this.currentIndent + "  ";
+    return this;
+  }
+  dedent() {
+    this.currentIndent = this.currentIndent.slice(0, -2);
+    return this;
+  }
+  newline() {
+    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(name) {
+    this.paramData.push(ParamData.Named(name));
+    return this.raw(INSERT_PARAM);
+  }
+  addParam(name) {
+    return this.space().param(name);
+  }
+  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) {
+    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/src/lib/Table.js

@@ -0,0 +1,130 @@
+// src/lib/Table.ts
+import { Cursor } from "./Cursor.js";
+import { Expr, ExprData } from "./Expr.js";
+import { Query } from "./Query.js";
+import { Selection } from "./Selection.js";
+import { Target } from "./Target.js";
+var Table = class extends Cursor.SelectMultiple {
+  [Selection.__tableType]() {
+    throw "assert";
+  }
+  constructor(schema) {
+    super(
+      Query.Select({
+        from: Target.Table(schema),
+        selection: ExprData.Row(Target.Table(schema))
+      })
+    );
+    Object.defineProperty(this, "schema", {
+      enumerable: false,
+      value: () => schema
+    });
+    if (schema.columns)
+      for (const column of Object.keys(schema.columns)) {
+        Object.defineProperty(this, column, {
+          enumerable: true,
+          get: () => this.get(column)
+        });
+      }
+    return new Proxy(this, {
+      get(target, key) {
+        return key in target ? target[key] : target.get(key);
+      }
+    });
+  }
+  fetch(id) {
+    return this.where(this.get("id").is(id)).first();
+  }
+  insertOne(record) {
+    return new Cursor(
+      Query.Insert({
+        into: this.schema(),
+        data: [record],
+        selection: ExprData.Row(Target.Table(this.schema())),
+        singleResult: true
+      })
+    );
+  }
+  insertAll(data) {
+    return new Cursor.Insert(this.schema()).values(...data);
+  }
+  set(data) {
+    return new Cursor.Update(
+      Query.Update({
+        table: this.schema()
+      })
+    ).set(data);
+  }
+  delete() {
+    return new Cursor.Delete(Query.Delete({ table: this.schema() }));
+  }
+  createTable() {
+    return new Cursor.Create(this.schema());
+  }
+  as(alias) {
+    return new Table({ ...this.schema(), alias });
+  }
+  alias() {
+    return new Proxy(
+      {},
+      {
+        get: (_, key) => {
+          return this.as(key);
+        }
+      }
+    );
+  }
+  get(name) {
+    return new Expr(ExprData.Field(this.toExpr().expr, name));
+  }
+  toExpr() {
+    return new Expr(
+      ExprData.Row(Target.Table(this.schema()))
+    );
+  }
+  schema() {
+    throw new Error("Not implemented");
+  }
+};
+function table(options) {
+  const schema = {
+    ...options,
+    columns: Object.fromEntries(
+      Object.entries(options.columns).map(([key, column]) => {
+        const { data } = column;
+        return [key, { ...data, name: data.name || key }];
+      })
+    ),
+    indexes: {}
+  };
+  const indexes = Object.fromEntries(
+    Object.entries(
+      options.indexes ? options.indexes.call(
+        new Expr(ExprData.Row(Target.Table(schema)))
+      ) : {}
+    ).map(([key, index]) => {
+      const indexName = `${schema.name}.${key}`;
+      return [indexName, { name: indexName, ...index.data }];
+    })
+  );
+  return new Table({
+    ...schema,
+    indexes
+  });
+}
+((table2) => {
+  function extend(target, extensions) {
+    return new Proxy(target, {
+      get(target2, key) {
+        if (key === "as")
+          return (...args) => extend(target2.as(...args), extensions);
+        return key in extensions ? extensions[key].bind(target2) : target2[key];
+      }
+    });
+  }
+  table2.extend = extend;
+})(table || (table = {}));
+export {
+  Table,
+  table
+};

package/dist/src/lib/Target.js

@@ -0,0 +1,37 @@
+// src/lib/Target.ts
+var TargetType = /* @__PURE__ */ ((TargetType2) => {
+  TargetType2["Each"] = "Each";
+  TargetType2["Table"] = "Table";
+  TargetType2["Join"] = "Join";
+  return TargetType2;
+})(TargetType || {});
+var Target;
+((Target2) => {
+  function Each(expr, alias) {
+    return { type: "Each" /* Each */, expr, alias };
+  }
+  Target2.Each = Each;
+  function Table(table) {
+    return { type: "Table" /* Table */, table };
+  }
+  Target2.Table = Table;
+  function Join(left, right, joinType, on) {
+    return { type: "Join" /* Join */, left, right, joinType, on };
+  }
+  Target2.Join = Join;
+  function source(from) {
+    switch (from.type) {
+      case "Table" /* Table */:
+        return from.table;
+      case "Join" /* Join */:
+        return source(from.left);
+      default:
+        return void 0;
+    }
+  }
+  Target2.source = source;
+})(Target || (Target = {}));
+export {
+  Target,
+  TargetType
+};

package/dist/src/sqlite/SqliteFormatter.js

@@ -0,0 +1,67 @@
+// src/sqlite/SqliteFormatter.ts
+import { ExprType } from "../lib/Expr.js";
+import { Formatter } from "../lib/Formatter.js";
+import { TargetType } from "../lib/Target.js";
+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:
+        if (expr.method === "match") {
+          const [from, query] = expr.params;
+          if (from.type !== ExprType.Row)
+            throw new Error("not implemented");
+          if (from.target.type !== TargetType.Table)
+            throw new Error("not implemented");
+          stmt.identifier(from.target.table.alias || from.target.table.name).raw(" MATCH ");
+          this.formatExprValue(ctx, query);
+          return stmt;
+        }
+      default:
+        return super.formatExpr(ctx, expr);
+    }
+  }
+};
+export {
+  SqliteFormatter
+};

package/dist/src/sqlite/SqliteFunctions.js

@@ -0,0 +1,146 @@
+// src/sqlite/SqliteFunctions.ts
+import { Functions } from "../lib/Functions.js";
+var SqliteFunctions = Functions;
+var {
+  count,
+  iif,
+  exists,
+  match,
+  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,
+  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,
+  soundex,
+  sqlite_version,
+  sqrt,
+  strftime,
+  substr,
+  sum,
+  tan,
+  tanh,
+  time,
+  total_changes,
+  trim,
+  trunc,
+  unicode,
+  unlikely,
+  upper
+};