rado 0.4.6 → 0.4.7

package/dist/src/lib/OrderBy.js

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

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

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

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

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

package/dist/src/lib/Statement.js

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

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

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

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

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