rado 0.3.2 → 0.3.3

package/dist/lib/Expr.js

@@ -1,284 +0,0 @@
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => {
-  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
-
-// src/lib/Expr.ts
-import { OrderDirection } from "./OrderBy.js";
-import { ParamData, ParamType } from "./Param.js";
-import { Target } from "./Target.js";
-var UnOp = /* @__PURE__ */ ((UnOp2) => {
-  UnOp2["Not"] = "Not";
-  UnOp2["IsNull"] = "IsNull";
-  return UnOp2;
-})(UnOp || {});
-var BinOp = /* @__PURE__ */ ((BinOp2) => {
-  BinOp2["Add"] = "Add";
-  BinOp2["Subt"] = "Subt";
-  BinOp2["Mult"] = "Mult";
-  BinOp2["Mod"] = "Mod";
-  BinOp2["Div"] = "Div";
-  BinOp2["Greater"] = "Greater";
-  BinOp2["GreaterOrEqual"] = "GreaterOrEqual";
-  BinOp2["Less"] = "Less";
-  BinOp2["LessOrEqual"] = "LessOrEqual";
-  BinOp2["Equals"] = "Equals";
-  BinOp2["NotEquals"] = "NotEquals";
-  BinOp2["And"] = "And";
-  BinOp2["Or"] = "Or";
-  BinOp2["Like"] = "Like";
-  BinOp2["Glob"] = "Glob";
-  BinOp2["Match"] = "Match";
-  BinOp2["In"] = "In";
-  BinOp2["NotIn"] = "NotIn";
-  BinOp2["Concat"] = "Concat";
-  return BinOp2;
-})(BinOp || {});
-var ExprType = /* @__PURE__ */ ((ExprType2) => {
-  ExprType2["UnOp"] = "UnOp";
-  ExprType2["BinOp"] = "BinOp";
-  ExprType2["Field"] = "Field";
-  ExprType2["Param"] = "Param";
-  ExprType2["Call"] = "Call";
-  ExprType2["Query"] = "Query";
-  ExprType2["Record"] = "Record";
-  ExprType2["Row"] = "Row";
-  ExprType2["Map"] = "Map";
-  ExprType2["Filter"] = "Filter";
-  ExprType2["Merge"] = "Merge";
-  ExprType2["Case"] = "Case";
-  return ExprType2;
-})(ExprType || {});
-var ExprData = {
-  UnOp(op, expr) {
-    return { type: "UnOp" /* UnOp */, op, expr };
-  },
-  BinOp(op, a, b) {
-    return { type: "BinOp" /* BinOp */, op, a, b };
-  },
-  Field(expr, field) {
-    return { type: "Field" /* Field */, expr, field };
-  },
-  Param(param) {
-    return { type: "Param" /* Param */, param };
-  },
-  Call(method, params) {
-    return { type: "Call" /* Call */, method, params };
-  },
-  Query(query) {
-    return { type: "Query" /* Query */, query };
-  },
-  Record(fields) {
-    return { type: "Record" /* Record */, fields };
-  },
-  Merge(a, b) {
-    return { type: "Merge" /* Merge */, a, b };
-  },
-  Row(target) {
-    return { type: "Row" /* Row */, target };
-  },
-  Map(target, result) {
-    return { type: "Map" /* Map */, target, result };
-  },
-  Filter(target, condition) {
-    return { type: "Filter" /* Filter */, target, condition };
-  },
-  Case(expr, cases, defaultCase) {
-    return { type: "Case" /* Case */, expr, cases, defaultCase };
-  },
-  create(input) {
-    if (input === null || input === void 0)
-      return ExprData.Param(ParamData.Value(null));
-    if (input && typeof input === "object" && typeof input.toExpr === "function")
-      input = input.toExpr();
-    if (input instanceof Expr)
-      return input.expr;
-    if (input && typeof input === "object" && !Array.isArray(input))
-      return ExprData.Record(
-        Object.fromEntries(
-          Object.entries(input).map(([key, value]) => [
-            key,
-            ExprData.create(value)
-          ])
-        )
-      );
-    return ExprData.Param(ParamData.Value(input));
-  }
-};
-var toExpr = ExprData.create;
-function isConstant(e, value) {
-  switch (e.type) {
-    case "Param" /* Param */:
-      switch (e.param.type) {
-        case ParamType.Value:
-          return e.param.value == value;
-        default:
-          return false;
-      }
-    default:
-      return false;
-  }
-}
-var _Expr = class {
-  constructor(expr) {
-    this.expr = expr;
-    return new Proxy(this, {
-      get(target, key) {
-        return key in target ? target[key] : target.get(key);
-      }
-    });
-  }
-  static value(value) {
-    return new _Expr(ExprData.Param(ParamData.Value(value)));
-  }
-  static create(input) {
-    if (input instanceof _Expr)
-      return input;
-    return new _Expr(ExprData.create(input));
-  }
-  static and(...conditions) {
-    return conditions.map(_Expr.create).reduce((condition, expr) => condition.and(expr), _Expr.value(true));
-  }
-  static or(...conditions) {
-    return conditions.map(_Expr.create).reduce((condition, expr) => condition.or(expr), _Expr.value(false));
-  }
-  asc() {
-    return { expr: this.expr, order: OrderDirection.Asc };
-  }
-  desc() {
-    return { expr: this.expr, order: OrderDirection.Desc };
-  }
-  not() {
-    return unop(this, "Not" /* Not */);
-  }
-  or(that) {
-    const a = this.expr;
-    const b = toExpr(that);
-    if (isConstant(b, true) || isConstant(a, false))
-      return new _Expr(b);
-    if (isConstant(a, true) || isConstant(b, false))
-      return this;
-    return new _Expr(ExprData.BinOp("Or" /* Or */, a, b));
-  }
-  and(that) {
-    const a = this.expr;
-    const b = toExpr(that);
-    if (isConstant(b, true) || isConstant(a, false))
-      return this;
-    if (isConstant(a, true) || isConstant(b, false))
-      return new _Expr(b);
-    return new _Expr(ExprData.BinOp("And" /* And */, a, b));
-  }
-  isNull() {
-    return unop(this, "IsNull" /* IsNull */);
-  }
-  isNotNull() {
-    return this.isNull().not();
-  }
-  isNot(that) {
-    if (that == null || that instanceof _Expr && isConstant(that.expr, null))
-      return this.isNotNull();
-    return binop(this, "NotEquals" /* NotEquals */, that);
-  }
-  is(that) {
-    if (that === null || that instanceof _Expr && isConstant(that.expr, null))
-      return this.isNull();
-    return binop(this, "Equals" /* Equals */, that);
-  }
-  in(that) {
-    return binop(this, "In" /* In */, that);
-  }
-  notIn(that) {
-    return binop(this, "NotIn" /* NotIn */, that);
-  }
-  add(that) {
-    return binop(this, "Add" /* Add */, that);
-  }
-  substract(that) {
-    return binop(this, "Subt" /* Subt */, that);
-  }
-  multiply(that) {
-    return binop(this, "Mult" /* Mult */, that);
-  }
-  remainder(that) {
-    return binop(this, "Mod" /* Mod */, that);
-  }
-  divide(that) {
-    return binop(this, "Div" /* Div */, that);
-  }
-  greater(that) {
-    return binop(this, "Greater" /* Greater */, that);
-  }
-  greaterOrEqual(that) {
-    return binop(this, "GreaterOrEqual" /* GreaterOrEqual */, that);
-  }
-  less(that) {
-    return binop(this, "Less" /* Less */, that);
-  }
-  lessOrEqual(that) {
-    return binop(this, "LessOrEqual" /* LessOrEqual */, that);
-  }
-  concat(that) {
-    return binop(this, "Concat" /* Concat */, that);
-  }
-  like(that) {
-    return binop(this, "Like" /* Like */, that);
-  }
-  glob(that) {
-    return binop(this, "Glob" /* Glob */, that);
-  }
-  match(that) {
-    return binop(this, "Match" /* Match */, that);
-  }
-  with(that) {
-    return new _Expr(
-      ExprData.Merge(this.expr, ExprData.create(that))
-    );
-  }
-  at(index) {
-    return this.get(`[${Number(index)}]`);
-  }
-  filter(fn) {
-    const alias = `__${Math.random().toString(36).slice(2, 9)}`;
-    const target = Target.Expr(this.expr, alias);
-    return new _Expr(
-      ExprData.Filter(
-        target,
-        ExprData.create(fn(new _Expr(ExprData.Row(target))))
-      )
-    );
-  }
-  map(fn) {
-    const alias = `__${Math.random().toString(36).slice(2, 9)}`;
-    const target = Target.Expr(this.expr, alias);
-    return new _Expr(
-      ExprData.Map(
-        target,
-        ExprData.create(fn(new _Expr(ExprData.Row(target))))
-      )
-    );
-  }
-  sure() {
-    return this;
-  }
-  get(name) {
-    return new _Expr(ExprData.Field(this.expr, name));
-  }
-};
-var Expr = _Expr;
-__publicField(Expr, "NULL", toExpr(null));
-function unop(self, type) {
-  return new Expr(ExprData.UnOp(type, self.expr));
-}
-function binop(self, type, that) {
-  return new Expr(ExprData.BinOp(type, self.expr, toExpr(that)));
-}
-export {
-  BinOp,
-  Expr,
-  ExprData,
-  ExprType,
-  UnOp
-};

package/dist/lib/Fields.d.ts

@@ -1,13 +0,0 @@
-import { Column, PrimaryKey } from './Column';
-import { Expr } from './Expr';
-type ObjectUnion<T> = {
-    [K in T extends infer P ? keyof P : never]: T extends infer P ? K extends keyof P ? P[K] : never : never;
-};
-type RecordField<T> = Expr<T> & FieldsOf<ObjectUnion<T>>;
-type Field<T> = [T] extends [Array<any>] ? Expr<T> : [T] extends [Column.IsPrimary<infer V, infer K>] ? Expr<PrimaryKey<V, K>> : [T] extends [Column.IsOptional<infer V>] ? Field<V> : [T] extends [number | string | boolean] ? Expr<T> : [T] extends [Record<string, any> | null] ? RecordField<T> : Expr<T>;
-type FieldsOf<Row> = Row extends Record<string, any> ? {
-    [K in keyof Row]-?: Field<Row[K]>;
-} : never;
-type IsStrictlyAny<T> = (T extends never ? true : false) extends false ? false : true;
-export type Fields<T> = IsStrictlyAny<T> extends true ? any : T extends object ? FieldsOf<T> : Field<T>;
-export {};

package/dist/lib/Functions.d.ts

@@ -1,5 +0,0 @@
-import { Expr } from './Expr';
-export declare const Functions: Functions;
-export type Functions = {
-    [key: string]: (...args: Array<any>) => Expr<any>;
-};

package/dist/lib/Functions.js

@@ -1,11 +0,0 @@
-// src/lib/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/lib/Id.d.ts

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

package/dist/lib/Index.d.ts

@@ -1,17 +0,0 @@
-import { Expr, ExprData } from './Expr';
-interface PartialIndexData {
-    on: Array<ExprData>;
-    unique?: boolean;
-    where?: ExprData;
-}
-export interface IndexData extends PartialIndexData {
-    name: string;
-}
-export declare class Index {
-    data: PartialIndexData;
-    constructor(data: PartialIndexData);
-    unique(): Index;
-    where(where: Expr<boolean>): Index;
-}
-export declare function index(...on: Array<Expr<any>>): Index;
-export {};

package/dist/lib/Index.js

@@ -1,20 +0,0 @@
-// src/lib/Index.ts
-import { ExprData } from "./Expr.js";
-var Index = class {
-  constructor(data) {
-    this.data = data;
-  }
-  unique() {
-    return new Index({ ...this.data, unique: true });
-  }
-  where(where) {
-    return new Index({ ...this.data, where: ExprData.create(where) });
-  }
-};
-function index(...on) {
-  return new Index({ on: on.map(ExprData.create) });
-}
-export {
-  Index,
-  index
-};

package/dist/lib/Ops.d.ts

@@ -1,7 +0,0 @@
-import { Cursor } from './Cursor';
-import { Table } from './Table';
-export declare function from<Row>(source: Table<Row> | Cursor.SelectMultiple<Row>): Cursor.SelectMultiple<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;
-export declare function create(...tables: Array<Table<any>>): Cursor.Batch;

package/dist/lib/Ops.js

@@ -1,36 +0,0 @@
-// src/lib/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 from(source) {
-  const target = "schema" in source ? Target.Table(source.schema()) : Target.Query(source.query());
-  return new Cursor.SelectMultiple(
-    Query.Select({
-      from: target,
-      selection: ExprData.Row(target)
-    })
-  );
-}
-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,
-  from,
-  insertInto,
-  update
-};

package/dist/lib/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/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/lib/Param.d.ts

@@ -1,20 +0,0 @@
-import { Expr } from './Expr';
-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;
-};
-export type Params<T> = {
-    [K in keyof T]: Expr<T[K]>;
-};
-export declare function createParams<T>(): Params<T>;

package/dist/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/lib/Query.d.ts

@@ -1,109 +0,0 @@
-import { ColumnData } from './Column';
-import { ExprData } from './Expr';
-import { IndexData } from './Index';
-import { OrderBy } from './OrderBy';
-import { Schema } from './Schema';
-import { Target } from './Target';
-export declare enum QueryType {
-    Insert = "Insert",
-    Select = "Select",
-    Update = "Update",
-    Delete = "Delete",
-    CreateTable = "CreateTable",
-    CreateIndex = "CreateIndex",
-    DropIndex = "DropIndex",
-    AlterTable = "AlterTable",
-    Batch = "Batch",
-    Transaction = "Transaction",
-    Raw = "Raw"
-}
-export type Query<T = any> = Query.Insert | Query.Select | Query.Update | Query.Delete | Query.CreateTable | Query.CreateIndex | Query.DropIndex | 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;
-        validate?: 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 CreateIndex extends QueryBase {
-        type: QueryType.CreateIndex;
-        table: Schema;
-        index: IndexData;
-        ifNotExists?: boolean;
-    }
-    function CreateIndex(create: Omit<CreateIndex, 'type'>): Query.CreateIndex;
-    interface DropIndex extends QueryBase {
-        type: QueryType.DropIndex;
-        table: Schema;
-        name: string;
-        ifExists?: boolean;
-    }
-    function DropIndex(drop: Omit<DropIndex, 'type'>): Query.DropIndex;
-    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?: ColumnData;
-        addColumn?: ColumnData;
-        dropColumn?: string;
-    }
-    function AlterTable(alter: Omit<AlterTable, 'type'>): Query.AlterTable;
-}

package/dist/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/lib/Schema.d.ts

@@ -1,18 +0,0 @@
-import { ColumnData } from './Column';
-import { Formatter } from './Formatter';
-import { IndexData } from './Index';
-import { Query } from './Query';
-export interface Schema {
-    name: string;
-    alias?: string;
-    columns: Record<string, ColumnData>;
-    indexes: Record<string, IndexData>;
-}
-export interface SchemaInstructions {
-    columns: Record<string, string>;
-    indexes: Record<string, string>;
-}
-export declare namespace Schema {
-    function create(schema: Schema): Query.Batch;
-    function upgrade(formatter: Formatter, local: SchemaInstructions, schema: Schema): Array<Query>;
-}