rado 0.1.62 → 0.1.64

package/dist/Formatter.js

@@ -1,496 +0,0 @@
-// src/Formatter.ts
-import { ColumnType } from "./Column.js";
-import { BinOp, ExprData, ExprType, UnOp } from "./Expr.js";
-import { OrderDirection } from "./OrderBy.js";
-import { ParamType } from "./Param.js";
-import { Query, QueryType } from "./Query.js";
-import {
-  Statement,
-  call,
-  identifier,
-  newline,
-  parenthesis,
-  raw,
-  separated,
-  value
-} from "./Statement.js";
-import { Target, TargetType } from "./Target.js";
-var binOps = {
-  [BinOp.Add]: "+",
-  [BinOp.Subt]: "-",
-  [BinOp.Mult]: "*",
-  [BinOp.Mod]: "%",
-  [BinOp.Div]: "/",
-  [BinOp.Greater]: ">",
-  [BinOp.GreaterOrEqual]: ">=",
-  [BinOp.Less]: "<",
-  [BinOp.LessOrEqual]: "<=",
-  [BinOp.Equals]: "=",
-  [BinOp.NotEquals]: "!=",
-  [BinOp.And]: "and",
-  [BinOp.Or]: "or",
-  [BinOp.Like]: "like",
-  [BinOp.Glob]: "glob",
-  [BinOp.Match]: "match",
-  [BinOp.In]: "in",
-  [BinOp.NotIn]: "not in",
-  [BinOp.Concat]: "||"
-};
-var joins = {
-  left: "left",
-  inner: "inner"
-};
-var Formatter = class {
-  constructor() {
-  }
-  formatAccess(on, field, formatAsJson) {
-    return formatAsJson ? this.formatJsonAccess(on, field) : this.formatSqlAccess(on, field);
-  }
-  compile(query, formatInline = false) {
-    const result = this.format(query, {
-      formatSubject: (select) => call("json_object", raw("'result'"), select),
-      nameResult: "result"
-    }).compile(this, formatInline);
-    return result;
-  }
-  format(query, ctx = {}) {
-    switch (query.type) {
-      case QueryType.Select:
-        return this.formatSelect(query, ctx);
-      case QueryType.Insert:
-        return this.formatInsert(query, ctx);
-      case QueryType.Update:
-        return this.formatUpdate(query, ctx);
-      case QueryType.Delete:
-        return this.formatDelete(query, ctx);
-      case QueryType.CreateTable:
-        return this.formatCreateTable(query, ctx);
-      case QueryType.CreateIndex:
-        return this.formatCreateIndex(query, ctx);
-      case QueryType.DropIndex:
-        return this.formatDropIndex(query, ctx);
-      case QueryType.AlterTable:
-        return this.formatAlterTable(query, ctx);
-      case QueryType.Transaction:
-        return this.formatTransaction(query, ctx);
-      case QueryType.Batch:
-        return this.formatBatch(query.queries, ctx);
-      case QueryType.Raw:
-        return this.formatRaw(query, ctx);
-    }
-  }
-  formatSelect(query, ctx) {
-    return raw("select").add(this.formatSelection(query.selection, ctx)).addLine("from").add(this.formatTarget(query.from, ctx)).add(this.formatWhere(query.where, ctx)).add(this.formatGroupBy(query.groupBy, ctx)).add(this.formatHaving(query.having, ctx)).add(this.formatOrderBy(query.orderBy, ctx)).add(this.formatLimit(query, ctx));
-  }
-  formatInsert(query, ctx) {
-    const columns = Object.values(query.into.columns);
-    return raw("insert into").addCall(
-      query.into.name,
-      ...columns.map((column) => this.formatString(column.name))
-    ).add("values").addSeparated(
-      query.data.map((row) => this.formatInsertRow(query.into.columns, row))
-    ).addIf(
-      query.selection,
-      () => raw("returning").add(this.formatSelection(query.selection, ctx))
-    );
-  }
-  formatUpdate(query, ctx) {
-    const data = query.set || {};
-    return raw("update").addIdentifier(query.table.name).add("set").addSeparated(
-      Object.keys(data).map((key) => {
-        const column = query.table.columns[key];
-        const exprData = data[key];
-        return identifier(key).add("=").add(
-          this.formatExpr(ExprData.create(data[key]), {
-            ...ctx,
-            formatAsJson: true
-          })
-        );
-      })
-    ).add(this.formatWhere(query.where, ctx)).add(this.formatLimit(query, ctx));
-  }
-  formatDelete(query, ctx) {
-    return raw("delete from").addIdentifier(query.table.name).add(this.formatWhere(query.where, ctx)).add(this.formatLimit(query, ctx));
-  }
-  formatCreateTable(query, ctx) {
-    return raw("create table").addIf(query.ifNotExists, "if not exists").addCall(
-      query.table.name,
-      ...Object.values(query.table.columns).map((column) => {
-        return this.formatColumn(column);
-      })
-    );
-  }
-  formatCreateIndex(query, ctx = {}) {
-    return raw("create index").addIf(query.ifNotExists, "if not exists").addIdentifier(query.index.name).add("on").addIdentifier(query.table.name).parenthesis(
-      separated(
-        query.index.on.map(
-          (expr) => this.formatExprValue(expr, { ...ctx, skipTableName: true })
-        )
-      )
-    ).add(this.formatWhere(query.where, ctx));
-  }
-  formatDropIndex(query, ctx) {
-    return raw("drop index").addIf(query.ifExists, "if exists").addIdentifier(query.name);
-  }
-  formatAlterTable(query, ctx) {
-    let stmt = raw("alter table").addIdentifier(query.table.name);
-    if (query.addColumn) {
-      stmt = stmt.add("add column").add(this.formatColumn(query.addColumn));
-    } else if (query.dropColumn) {
-      stmt = stmt.add("drop column").addIdentifier(query.dropColumn);
-    } else if (query.alterColumn) {
-      throw new Error(`Not available in this formatter: alter column`);
-    }
-    return stmt;
-  }
-  formatTransaction({ op, id }, ctx) {
-    switch (op) {
-      case Query.TransactionOperation.Begin:
-        return raw("savepoint").addIdentifier(id);
-      case Query.TransactionOperation.Commit:
-        return raw("release").addIdentifier(id);
-      case Query.TransactionOperation.Rollback:
-        return raw("rollback to").addIdentifier(id);
-    }
-  }
-  formatBatch(queries, ctx) {
-    return separated(
-      queries.map((query) => this.format(query, ctx)),
-      "; "
-    );
-  }
-  formatRaw({ strings, params }, ctx) {
-    return Statement.tag(strings, ...params);
-  }
-  formatColumn(column) {
-    return identifier(column.name).add(this.formatType(column.type)).addIf(column.unique, "unique").addIf(column.autoIncrement, "autoincrement").addIf(column.primaryKey, "primary key").addIf(!column.nullable, "not null").addIf(
-      column.defaultValue !== void 0,
-      raw("default").add(this.formatInlineValue(column.defaultValue))
-    ).addIf(column.references, () => {
-      return this.formatContraintReference(column.references);
-    });
-  }
-  formatContraintReference(reference) {
-    if (reference.type !== ExprType.Field || reference.expr.type !== ExprType.Row)
-      throw new Error("not supported");
-    const from = reference.expr.target;
-    return raw("references").addIdentifier(Target.source(from).name).parenthesis(identifier(reference.field));
-  }
-  formatType(type) {
-    switch (type) {
-      case ColumnType.String:
-        return raw("text");
-      case ColumnType.Json:
-        return raw("json");
-      case ColumnType.Number:
-        return raw("numeric");
-      case ColumnType.Boolean:
-        return raw("boolean");
-      case ColumnType.Integer:
-        return raw("integer");
-    }
-  }
-  formatInsertRow(columns, row) {
-    return parenthesis(
-      separated(
-        Object.entries(columns).map(([property, column]) => {
-          const columnValue = row[property];
-          return this.formatColumnValue(column, columnValue);
-        })
-      )
-    );
-  }
-  formatColumnValue(column, columnValue) {
-    const isNull = columnValue === void 0 || columnValue === null;
-    const isOptional = column.nullable || column.autoIncrement || column.primaryKey || column.defaultValue;
-    if (isNull) {
-      if (!isOptional)
-        throw new TypeError(`Expected value for column ${column.name}`);
-      return raw("null");
-    }
-    switch (column.type) {
-      case ColumnType.String:
-        if (typeof columnValue !== "string")
-          throw new TypeError(`Expected string for column ${column.name}`);
-        return value(columnValue);
-      case ColumnType.Integer:
-      case ColumnType.Number:
-        if (typeof columnValue !== "number")
-          throw new TypeError(`Expected number for column ${column.name}`);
-        return value(columnValue);
-      case ColumnType.Boolean:
-        if (typeof columnValue !== "boolean")
-          throw new TypeError(`Expected boolean for column ${column.name}`);
-        return value(columnValue);
-      case ColumnType.Json:
-        if (typeof columnValue !== "object")
-          throw new TypeError(`Expected object for column ${column.name}`);
-        return value(JSON.stringify(columnValue));
-    }
-  }
-  formatTarget(target, ctx) {
-    switch (target.type) {
-      case TargetType.Table:
-        return identifier(target.table.name).addIf(
-          target.table.alias,
-          () => raw("as").addIdentifier(target.table.alias)
-        );
-      case TargetType.Join:
-        const { left, right, joinType } = target;
-        return this.formatTarget(left, ctx).addLine(joins[joinType]).add("join").add(this.formatTarget(right, ctx)).add("on").add(this.formatExprValue(target.on, ctx));
-      default:
-        throw new Error(`Cannot format target of type ${target.type}`);
-    }
-  }
-  formatWhere(expr, ctx) {
-    if (!expr)
-      return;
-    return newline().raw("where").add(this.formatExprValue(expr, ctx));
-  }
-  formatHaving(expr, ctx) {
-    if (!expr)
-      return;
-    return newline().raw("having").add(this.formatExprValue(expr, ctx));
-  }
-  formatGroupBy(groupBy, ctx) {
-    if (!groupBy)
-      return;
-    return newline().raw("group by").addSeparated(groupBy.map((expr) => this.formatExprValue(expr, ctx)));
-  }
-  formatOrderBy(orderBy, ctx) {
-    if (!orderBy)
-      return;
-    return newline().raw("order by").addSeparated(
-      orderBy.map(
-        ({ expr, order }) => this.formatExprValue(expr, ctx).add(
-          order === OrderDirection.Asc ? "asc" : "desc"
-        )
-      )
-    );
-  }
-  formatLimit({ limit, offset, singleResult }, ctx) {
-    if (!limit && !offset && !singleResult)
-      return;
-    return newline().raw("limit").addValue(singleResult ? 1 : limit).addIf(offset && offset > 0, raw("offset").addValue(offset));
-  }
-  formatSelection(selection, ctx) {
-    const { formatSubject } = ctx;
-    const subject = this.formatExpr(selection, {
-      ...ctx,
-      formatSubject: void 0,
-      formatAsJson: true
-    });
-    return (formatSubject ? formatSubject(subject) : subject).addIf(
-      ctx.nameResult,
-      raw("as").addIdentifier(ctx.nameResult)
-    );
-  }
-  formatExprValue(expr, ctx) {
-    return this.formatExpr(expr, { ...ctx, formatAsJson: false });
-  }
-  formatIn(expr, ctx) {
-    switch (expr.type) {
-      case ExprType.Field:
-        return this.formatUnwrapArray(this.formatExprValue(expr, ctx));
-      default:
-        return this.formatExprValue(expr, ctx);
-    }
-  }
-  formatUnwrapArray(stmt) {
-    return parenthesis(raw("select value from").addCall("json_each", stmt));
-  }
-  retrieveField(expr, field) {
-    switch (expr.type) {
-      case ExprType.Record:
-        return expr.fields[field];
-      case ExprType.Merge:
-        return this.retrieveField(expr.a, field) || this.retrieveField(expr.b, field);
-      default:
-        return void 0;
-    }
-  }
-  formatField(expr, field, ctx) {
-    const fieldExpr = this.retrieveField(expr, field);
-    if (fieldExpr)
-      return this.formatExpr(fieldExpr, ctx);
-    switch (expr.type) {
-      case ExprType.Row:
-        switch (expr.target.type) {
-          case TargetType.Table:
-            const selection = ctx.skipTableName ? identifier(field) : identifier(expr.target.table.alias || expr.target.table.name).raw(".").identifier(field);
-            const column = expr.target.table.columns[field];
-            switch (column?.type) {
-              case ColumnType.Json:
-                return call("json", selection);
-              default:
-                return selection;
-            }
-        }
-      default:
-        return this.formatAccess(
-          this.formatExpr(expr, { ...ctx, formatAsJson: true }),
-          field,
-          ctx.formatAsJson
-        );
-    }
-  }
-  formatString(input) {
-    return raw(this.escapeValue(String(input)));
-  }
-  formatInlineValue(rawValue) {
-    switch (true) {
-      case (rawValue === null || rawValue === void 0):
-        return raw("null");
-      case typeof rawValue === "boolean":
-        return rawValue ? raw("true") : raw("false");
-      case (typeof rawValue === "string" || typeof rawValue === "number"):
-        return this.formatString(rawValue);
-      default:
-        return this.formatString(JSON.stringify(rawValue));
-    }
-  }
-  formatValue(rawValue, formatAsJson) {
-    switch (true) {
-      case (rawValue === null || rawValue === void 0):
-        return raw("null");
-      case (!formatAsJson && typeof rawValue === "boolean"):
-        return rawValue ? raw("1") : raw("0");
-      case Array.isArray(rawValue):
-        const res = parenthesis(
-          separated(rawValue.map((v) => this.formatValue(v, false)))
-        );
-        return formatAsJson ? raw("json_array").concat(res) : res;
-      case (typeof rawValue === "string" || typeof rawValue === "number"):
-        return value(rawValue);
-      default:
-        const expr = this.formatString(JSON.stringify(rawValue));
-        if (formatAsJson)
-          return call("json", expr);
-        return expr;
-    }
-  }
-  formatExpr(expr, ctx) {
-    switch (expr.type) {
-      case ExprType.UnOp:
-        switch (expr.op) {
-          case UnOp.IsNull:
-            return this.formatExprValue(expr.expr, ctx).add("is null");
-          case UnOp.Not:
-            return raw("not").addParenthesis(
-              this.formatExprValue(expr.expr, ctx)
-            );
-        }
-      case ExprType.BinOp:
-        return parenthesis(
-          this.formatExprValue(expr.a, ctx).add(binOps[expr.op]).add(
-            expr.op === BinOp.In || expr.op === BinOp.NotIn ? this.formatIn(expr.b, ctx) : this.formatExprValue(expr.b, ctx)
-          )
-        );
-      case ExprType.Param:
-        switch (expr.param.type) {
-          case ParamType.Value:
-            return this.formatValue(expr.param.value, ctx.formatAsJson);
-          case ParamType.Named:
-            throw new Error("todo");
-        }
-      case ExprType.Field:
-        return this.formatField(expr.expr, expr.field, ctx);
-      case ExprType.Call: {
-        if (expr.method === "cast") {
-          const [e, type] = expr.params;
-          const typeName = type.type === ExprType.Param && type.param.type === ParamType.Value && type.param.value;
-          return raw("cast").parenthesis(
-            this.formatExprValue(e, ctx).add("as").add(this.formatString(typeName))
-          );
-        } else {
-          const params = expr.params.map(
-            (expr2) => this.formatExprValue(expr2, ctx)
-          );
-          return call(expr.method, ...params);
-        }
-      }
-      case ExprType.Query:
-        if (!ctx.formatAsJson)
-          return parenthesis(this.format(expr.query, ctx));
-        const subQuery = this.format(expr.query, { ...ctx, nameResult: "result" });
-        if (expr.query.singleResult)
-          return call("json", parenthesis(subQuery));
-        return parenthesis(
-          raw("select json_group_array(json(result))").newline().raw("from ").parenthesis(subQuery)
-        );
-      case ExprType.Row:
-        switch (expr.target.type) {
-          case TargetType.Table:
-            const table = Target.source(expr.target);
-            if (!table)
-              throw new Error(`Cannot select empty target`);
-            return this.formatExpr(
-              ExprData.Record(
-                Object.fromEntries(
-                  Object.entries(table.columns).map(([key, column]) => [
-                    key,
-                    ExprData.Field(ExprData.Row(expr.target), column.name)
-                  ])
-                )
-              ),
-              ctx
-            );
-          case TargetType.Each:
-            return identifier(expr.target.alias).raw(".value");
-          default:
-            throw new Error(`Cannot select from ${expr.target.type}`);
-        }
-      case ExprType.Merge:
-        return call(
-          "json_patch",
-          this.formatExpr(expr.a, { ...ctx, formatAsJson: true }),
-          this.formatExpr(expr.b, { ...ctx, formatAsJson: true })
-        );
-      case ExprType.Record:
-        return call(
-          "json_object",
-          ...Object.entries(expr.fields).map(([key, value2]) => {
-            return this.formatString(key).raw(", ").concat(this.formatExpr(value2, { ...ctx, formatAsJson: true }));
-          })
-        );
-      case ExprType.Filter: {
-        const { target, condition } = expr;
-        switch (target.type) {
-          case TargetType.Each:
-            return parenthesis(
-              raw("select json_group_array(json(result)) from").addParenthesis(
-                raw("select value as result").add("from").addCall(
-                  "json_each",
-                  this.formatExpr(target.expr, { ...ctx, formatAsJson: true })
-                ).add("as").addIdentifier(target.alias).add("where").add(this.formatExprValue(condition, ctx))
-              )
-            );
-          default:
-            throw new Error("todo");
-        }
-      }
-      case ExprType.Map: {
-        const { target, result } = expr;
-        switch (target.type) {
-          case TargetType.Each:
-            return parenthesis(
-              raw("select json_group_array(json(result)) from").addParenthesis(
-                raw("select").add(this.formatExpr(result, { ...ctx, formatAsJson: true })).add("as").addIdentifier("result").add("from").addCall(
-                  "json_each",
-                  this.formatExpr(target.expr, { ...ctx, formatAsJson: true })
-                ).add("as").addIdentifier(target.alias)
-              )
-            );
-          default:
-            throw new Error("todo");
-        }
-      }
-      default:
-        console.log(expr);
-        throw new Error("todo");
-    }
-  }
-};
-export {
-  Formatter
-};

package/dist/Functions.d.ts

@@ -1,7 +0,0 @@
-import { EV, Expr } from './Expr';
-export declare const Functions: Functions;
-/** These will have to be supported in every driver */
-export type Functions = {
-    count(x?: Expr<any>): Expr<number>;
-    iif<T>(x: EV<boolean>, y: EV<T>, z: EV<T>): Expr<T>;
-};

package/dist/Functions.js

@@ -1,11 +0,0 @@
-// src/Functions.ts
-import { Expr, ExprData } from "./Expr.js";
-function get(_, method) {
-  return (...args) => {
-    return new Expr(ExprData.Call(method, args.map(ExprData.create)));
-  };
-}
-var Functions = new Proxy({}, { get });
-export {
-  Functions
-};

package/dist/Id.d.ts

@@ -1,3 +0,0 @@
-export type Id<T extends {
-    id: any;
-}> = T['id'];

package/dist/Ops.d.ts

@@ -1,8 +0,0 @@
-import { Cursor } from './Cursor';
-import { Table } from './Table';
-export declare function selectAll<Row>(table: Table<Row>): Cursor.SelectMultiple<Row>;
-export declare function selectFirst<Row>(table: Table<Row>): Cursor.SelectSingle<Row>;
-export declare function update<Row>(table: Table<Row>): Cursor.Update<Row>;
-export declare function insertInto<Row>(table: Table<Row>): Cursor.Insert<Row>;
-export declare function deleteFrom<Row>(table: Table<Row>): Cursor.Delete<Row>;
-export declare function create(...tables: Array<Table<any>>): Cursor.Batch;

package/dist/Ops.js

@@ -1,45 +0,0 @@
-// src/Ops.ts
-import { Cursor } from "./Cursor.js";
-import { ExprData } from "./Expr.js";
-import { Query } from "./Query.js";
-import { Schema } from "./Schema.js";
-import { Target } from "./Target.js";
-function selectAll(table) {
-  return new Cursor.SelectMultiple(
-    Query.Select({
-      from: Target.Table(table.schema()),
-      selection: ExprData.Row(Target.Table(table.schema()))
-    })
-  );
-}
-function selectFirst(table) {
-  return new Cursor.SelectSingle(
-    Query.Select({
-      from: Target.Table(table.schema()),
-      selection: ExprData.Row(Target.Table(table.schema())),
-      singleResult: true
-    })
-  );
-}
-function update(table) {
-  return new Cursor.Update(Query.Update({ table: table.schema() }));
-}
-function insertInto(table) {
-  return new Cursor.Insert(table.schema());
-}
-function deleteFrom(table) {
-  return new Cursor.Delete(Query.Delete({ table: table.schema() }));
-}
-function create(...tables) {
-  return new Cursor.Batch(
-    tables.flatMap((table) => Schema.create(table.schema()).queries)
-  );
-}
-export {
-  create,
-  deleteFrom,
-  insertInto,
-  selectAll,
-  selectFirst,
-  update
-};

package/dist/OrderBy.d.ts

@@ -1,9 +0,0 @@
-import { ExprData } from './Expr';
-export declare enum OrderDirection {
-    Asc = "Asc",
-    Desc = "Desc"
-}
-export type OrderBy = {
-    expr: ExprData;
-    order: OrderDirection;
-};

package/dist/OrderBy.js

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

package/dist/Param.d.ts

@@ -1,15 +0,0 @@
-export declare enum ParamType {
-    Value = "Value",
-    Named = "Named"
-}
-export type ParamData = {
-    type: ParamType.Value;
-    value: any;
-} | {
-    type: ParamType.Named;
-    name: string;
-};
-export declare const ParamData: {
-    Value(value: any): ParamData;
-    Named(name: string): ParamData;
-};

package/dist/Param.js

@@ -1,18 +0,0 @@
-// src/Param.ts
-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 };
-  }
-};
-export {
-  ParamData,
-  ParamType
-};