rado 0.1.21 → 0.1.23

package/dist/Formatter.js

@@ -0,0 +1,453 @@
+// src/Formatter.ts
+import { ColumnType } from "./Column";
+import { BinOp, ExprData, ExprType, UnOp } from "./Expr";
+import { OrderDirection } from "./OrderBy";
+import { ParamType } from "./Param";
+import { Query, QueryType } from "./Query";
+import {
+  Statement,
+  call,
+  identifier,
+  newline,
+  parenthesis,
+  raw,
+  separated,
+  value
+} from "./Statement";
+import { Target, TargetType } from "./Target";
+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.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);
+      })
+    );
+  }
+  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.ofTemplate(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").value(column.defaultValue)
+    );
+  }
+  formatType(type) {
+    switch (type) {
+      case ColumnType.String:
+      case ColumnType.Object:
+      case ColumnType.Array:
+        return raw("text");
+      case ColumnType.Number:
+      case ColumnType.Boolean:
+        return raw("numeric");
+      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.Object:
+        if (typeof columnValue !== "object")
+          throw new TypeError(`Expected object for column ${column.name}`);
+        return value(JSON.stringify(columnValue));
+      case ColumnType.Array:
+        if (!Array.isArray(columnValue))
+          throw new TypeError(`Expected array 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 = identifier(
+              expr.target.table.alias || expr.target.table.name
+            ).raw(".").identifier(field);
+            const column = expr.target.table.columns[field];
+            switch (column?.type) {
+              case ColumnType.Array:
+              case ColumnType.Object:
+                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)));
+  }
+  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(",").newline().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

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

package/dist/Functions.js

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

package/dist/Key.d.ts

@@ -0,0 +1,5 @@
+import { ExprData } from './Expr';
+export interface Key {
+    name: string;
+    on: Array<ExprData>;
+}

package/dist/Ops.d.ts

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

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

package/dist/OrderBy.d.ts

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

package/dist/OrderBy.js

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

package/dist/Param.d.ts

@@ -0,0 +1,15 @@
+export declare const 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

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

package/dist/Query.d.ts

@@ -0,0 +1,94 @@
+import { ColumnData } from './Column';
+import { ExprData } from './Expr';
+import { Key } from './Key';
+import { OrderBy } from './OrderBy';
+import { Schema } from './Schema';
+import { Target } from './Target';
+export declare const enum QueryType {
+    Insert = "Insert",
+    Select = "Select",
+    Update = "Update",
+    Delete = "Delete",
+    CreateTable = "CreateTable",
+    AlterTable = "AlterTable",
+    Batch = "Batch",
+    Transaction = "Transaction",
+    Raw = "Raw"
+}
+export type Query<T = any> = Query.Insert | Query.Select | Query.Update | Query.Delete | Query.CreateTable | Query.AlterTable | Query.Batch | Query.Transaction | Query.Raw;
+export declare namespace Query {
+    interface QueryBase {
+        limit?: number;
+        offset?: number;
+        type: QueryType;
+        where?: ExprData;
+        orderBy?: Array<OrderBy>;
+        groupBy?: Array<ExprData>;
+        having?: ExprData;
+        selection?: ExprData;
+        singleResult?: boolean;
+    }
+    interface Insert extends QueryBase {
+        type: QueryType.Insert;
+        into: Schema;
+        data: Array<any>;
+    }
+    function Insert(insert: Omit<Insert, 'type'>): Query.Insert;
+    interface Select extends QueryBase {
+        type: QueryType.Select;
+        selection: ExprData;
+        from: Target;
+    }
+    function Select(select: Omit<Select, 'type'>): Query.Select;
+    interface Update extends QueryBase {
+        type: QueryType.Update;
+        table: Schema;
+        set?: Record<string, any>;
+    }
+    function Update(update: Omit<Update, 'type'>): Query.Update;
+    interface Delete extends QueryBase {
+        type: QueryType.Delete;
+        table: Schema;
+    }
+    function Delete(del: Omit<Delete, 'type'>): Query.Delete;
+    interface CreateTable extends QueryBase {
+        type: QueryType.CreateTable;
+        table: Schema;
+        ifNotExists?: boolean;
+    }
+    function CreateTable(create: Omit<CreateTable, 'type'>): Query.CreateTable;
+    interface Batch extends QueryBase {
+        type: QueryType.Batch;
+        queries: Array<Query<any>>;
+    }
+    function Batch(batch: Omit<Batch, 'type'>): Query.Batch;
+    enum TransactionOperation {
+        Begin = "Begin",
+        Commit = "Commit",
+        Rollback = "Rollback"
+    }
+    interface Transaction extends QueryBase {
+        type: QueryType.Transaction;
+        id: string;
+        op: TransactionOperation;
+    }
+    function Transaction(transaction: Omit<Transaction, 'type'>): Query.Transaction;
+    type RawReturn = 'row' | 'rows' | undefined;
+    interface Raw extends QueryBase {
+        type: QueryType.Raw;
+        expectedReturn?: 'row' | 'rows';
+        strings: ReadonlyArray<string>;
+        params: Array<any>;
+    }
+    function Raw(raw: Omit<Raw, 'type'>): Query.Raw;
+    interface AlterTable extends QueryBase {
+        type: QueryType.AlterTable;
+        table: Schema;
+        alterColumn?: [to: ColumnData, from: ColumnData | undefined];
+        addColumn?: ColumnData;
+        dropColumn?: ColumnData;
+        addKey?: Key;
+        dropKey?: Key;
+    }
+    function AlterTable(alter: Omit<AlterTable, 'type'>): Query.AlterTable;
+}