rado 0.1.63 → 0.2.0

package/dist/define/Cursor.js

@@ -4,6 +4,7 @@ import { Functions } from "./Functions.js";
 import { Query } from "./Query.js";
 import { Schema } from "./Schema.js";
 import { Selection } from "./Selection.js";
+import { createTable, table } from "./Table.js";
 import { Target } from "./Target.js";
 var Cursor = class {
   [Selection.__cursorType]() {
@@ -21,11 +22,18 @@ var Cursor = class {
   query() {
     throw new Error("Not implemented");
   }
+  next(cursor) {
+    return new Cursor(
+      Query.Batch({
+        queries: [this.query(), cursor.query()]
+      })
+    );
+  }
   on(driver) {
     return driver.executeQuery(this.query());
   }
-  compile(driver, options) {
-    return driver.formatter.compile(this.query(), options);
+  toSql(driver, options = { forceInline: true }) {
+    return driver.formatter.compile(this.query(), options).sql;
   }
   toJSON() {
     return this.query();
@@ -77,7 +85,7 @@ function addWhere(query, where) {
   class InsertValuesReturning extends Cursor2 {
   }
   Cursor2.InsertValuesReturning = InsertValuesReturning;
-  class InsertValues extends Cursor2 {
+  class Inserted extends Cursor2 {
     query() {
       return super.query();
     }
@@ -87,20 +95,25 @@ function addWhere(query, where) {
       );
     }
   }
-  Cursor2.InsertValues = InsertValues;
+  Cursor2.Inserted = Inserted;
   class Insert {
     constructor(into) {
       this.into = into;
     }
+    selection(query) {
+      return new Inserted(
+        Query.Insert({ into: this.into, select: query.query() })
+      );
+    }
     values(...data) {
-      return new InsertValues(Query.Insert({ into: this.into, data }));
+      return new Inserted(Query.Insert({ into: this.into, data }));
     }
   }
   Cursor2.Insert = Insert;
   class CreateTable extends Cursor2 {
-    constructor(table) {
-      super(Schema.create(table));
-      this.table = table;
+    constructor(table2) {
+      super(Schema.create(table2));
+      this.table = table2;
     }
   }
   Cursor2.CreateTable = CreateTable;
@@ -109,8 +122,36 @@ function addWhere(query, where) {
       super(Query.Batch({ queries }));
       this.queries = queries;
     }
+    query() {
+      return super.query();
+    }
+    next(cursor) {
+      return new Cursor2(
+        Query.Batch({
+          queries: [...this.query().queries, cursor.query()]
+        })
+      );
+    }
   }
   Cursor2.Batch = Batch;
+  function joinTarget(joinType, query, to, on) {
+    const toQuery = to instanceof Cursor2 ? to.query() : void 0;
+    const target = toQuery ? toQuery.from : Target.Table(to[table.data]);
+    if (!query.from || !target)
+      throw new Error("No from clause");
+    const conditions = [...on];
+    if (toQuery) {
+      const where = toQuery.where;
+      if (where)
+        conditions.push(new Expr(where));
+    }
+    return Target.Join(
+      query.from,
+      target,
+      joinType,
+      Expr.and(...conditions).expr
+    );
+  }
   class SelectMultiple extends Cursor2 {
     query() {
       return super.query();
@@ -119,24 +160,14 @@ function addWhere(query, where) {
       const query = this.query();
       return new SelectMultiple({
         ...query,
-        from: Target.Join(
-          query.from,
-          Target.Table(that.schema()),
-          "left",
-          Expr.and(...on).expr
-        )
+        from: joinTarget("left", query, that, on)
       });
     }
     innerJoin(that, ...on) {
       const query = this.query();
       return new SelectMultiple({
         ...query,
-        from: Target.Join(
-          query.from,
-          Target.Table(that.schema()),
-          "inner",
-          Expr.and(...on).expr
-        )
+        from: joinTarget("inner", query, that, on)
       });
     }
     select(selection) {
@@ -185,11 +216,65 @@ function addWhere(query, where) {
     skip(offset) {
       return new SelectMultiple({ ...this.query(), offset });
     }
-    toExpr() {
+    [Expr.toExpr]() {
       return new Expr(ExprData.Query(this.query()));
     }
   }
   Cursor2.SelectMultiple = SelectMultiple;
+  class TableSelect extends SelectMultiple {
+    constructor(table2, conditions = []) {
+      const target = Target.Table(table2);
+      super(
+        Query.Select({
+          from: target,
+          selection: ExprData.Row(target),
+          where: Expr.and(...conditions).expr
+        })
+      );
+      this.table = table2;
+    }
+    as(alias) {
+      return createTable({ ...this.table, alias });
+    }
+    create() {
+      return new Cursor2.CreateTable(this.table);
+    }
+    insertSelect(query) {
+      return new Cursor2.Inserted(
+        Query.Insert({ into: this.table, select: query.query() })
+      );
+    }
+    insertOne(record) {
+      return new Cursor2(
+        Query.Insert({
+          into: this.table,
+          data: [record],
+          selection: ExprData.Row(Target.Table(this.table)),
+          singleResult: true
+        })
+      );
+    }
+    insertAll(data) {
+      return new Cursor2.Insert(this.table).values(...data);
+    }
+    set(data) {
+      return new Cursor2.Update(
+        Query.Update({
+          table: this.table,
+          where: this.query().where
+        })
+      ).set(data);
+    }
+    delete() {
+      return new Cursor2.Delete(
+        Query.Delete({
+          table: this.table,
+          where: this.query().where
+        })
+      );
+    }
+  }
+  Cursor2.TableSelect = TableSelect;
   class SelectSingle extends Cursor2 {
     query() {
       return super.query();
@@ -198,24 +283,14 @@ function addWhere(query, where) {
       const query = this.query();
       return new SelectSingle({
         ...query,
-        from: Target.Join(
-          query.from,
-          Target.Table(that.schema()),
-          "left",
-          Expr.and(...on).expr
-        )
+        from: joinTarget("left", query, that, on)
       });
     }
     innerJoin(that, ...on) {
       const query = this.query();
       return new SelectSingle({
         ...query,
-        from: Target.Join(
-          query.from,
-          Target.Table(that.schema()),
-          "inner",
-          Expr.and(...on).expr
-        )
+        from: joinTarget("inner", query, that, on)
       });
     }
     select(selection) {
@@ -248,7 +323,7 @@ function addWhere(query, where) {
     all() {
       return new SelectMultiple({ ...this.query(), singleResult: false });
     }
-    toExpr() {
+    [Expr.toExpr]() {
       return new Expr(ExprData.Query(this.query()));
     }
   }

package/dist/define/Expr.d.ts

@@ -128,7 +128,8 @@ export declare const ExprData: {
 export type EV<T> = Expr<T> | T;
 export declare class Expr<T> {
     expr: ExprData;
-    static NULL: ExprData;
+    static NULL: Expr<null>;
+    static toExpr: symbol;
     static value<T>(value: T): Expr<T>;
     static create<T>(input: EV<T>): Expr<T>;
     static and(...conditions: Array<EV<boolean>>): Expr<boolean>;
@@ -139,27 +140,28 @@ export declare class Expr<T> {
     not(): Expr<boolean>;
     or(this: Expr<boolean>, that: EV<boolean>): Expr<boolean>;
     and(this: Expr<boolean>, that: EV<boolean>): Expr<boolean>;
+    is(that: EV<T> | Cursor.SelectSingle<T>): Expr<boolean>;
+    isNot(that: EV<T>): Expr<boolean>;
     isNull(): Expr<boolean>;
     isNotNull(): Expr<boolean>;
-    isNot(that: EV<T>): Expr<boolean>;
-    is(that: EV<T> | Cursor.SelectSingle<T>): Expr<boolean>;
-    in(that: EV<Array<T>> | Cursor.SelectMultiple<T>): Expr<boolean>;
-    notIn(that: EV<Array<T>> | Cursor.SelectMultiple<T>): Expr<boolean>;
+    isIn(that: EV<Array<T>> | Cursor.SelectMultiple<T>): Expr<boolean>;
+    isNotIn(that: EV<Array<T>> | Cursor.SelectMultiple<T>): Expr<boolean>;
+    isGreater(that: EV<any>): Expr<boolean>;
+    isGreaterOrEqual(that: EV<any>): Expr<boolean>;
+    isLess(that: EV<any>): Expr<boolean>;
+    isLessOrEqual(that: EV<any>): Expr<boolean>;
     add(this: Expr<number>, that: EV<number>): Expr<number>;
     substract(this: Expr<number>, that: EV<number>): Expr<number>;
     multiply(this: Expr<number>, that: EV<number>): Expr<number>;
     remainder(this: Expr<number>, that: EV<number>): Expr<number>;
     divide(this: Expr<number>, that: EV<number>): Expr<number>;
-    greater(that: EV<any>): Expr<boolean>;
-    greaterOrEqual(that: EV<any>): Expr<boolean>;
-    less(that: EV<any>): Expr<boolean>;
-    lessOrEqual(that: EV<any>): Expr<boolean>;
     concat(this: Expr<string>, that: EV<string>): Expr<string>;
     like(this: Expr<string>, that: EV<string>): Expr<boolean>;
     glob(this: Expr<string>, that: EV<string>): Expr<boolean>;
     match(this: Expr<string>, that: EV<string>): Expr<boolean>;
     with<X extends Selection>(that: X): Selection.With<T, X>;
     at<T>(this: Expr<Array<T>>, index: number): Expr<T | null>;
+    includes<T>(this: Expr<Array<T>>, value: EV<T>): Expr<boolean>;
     filter<T>(this: Expr<Array<T>>, fn: (cursor: Fields<T>) => Expr<boolean>): Expr<Array<T>>;
     map<T, X extends Selection>(this: Expr<Array<T>>, fn: (cursor: Fields<T>) => X): Expr<Array<Selection.Infer<X>>>;
     sure(): Expr<NonNullable<T>>;

package/dist/define/Expr.js

@@ -91,8 +91,8 @@ var ExprData = {
   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 && typeof input[Expr.toExpr] === "function")
+      input = input[Expr.toExpr]();
     if (input instanceof Expr)
       return input.expr;
     if (input && typeof input === "object" && !Array.isArray(input))
@@ -151,7 +151,7 @@ var _Expr = class {
     return { expr: this.expr, order: OrderDirection.Desc };
   }
   not() {
-    return unop(this, "Not" /* Not */);
+    return new _Expr(ExprData.UnOp("Not" /* Not */, this.expr));
   }
   or(that) {
     const a = this.expr;
@@ -171,66 +171,72 @@ var _Expr = class {
       return new _Expr(b);
     return new _Expr(ExprData.BinOp("And" /* And */, a, b));
   }
+  is(that) {
+    if (that === null || that instanceof _Expr && isConstant(that.expr, null))
+      return this.isNull();
+    return new _Expr(ExprData.BinOp("Equals" /* Equals */, this.expr, toExpr(that)));
+  }
+  isNot(that) {
+    if (that === null || that instanceof _Expr && isConstant(that.expr, null))
+      return this.isNotNull();
+    return new _Expr(
+      ExprData.BinOp("NotEquals" /* NotEquals */, this.expr, toExpr(that))
+    );
+  }
   isNull() {
-    return unop(this, "IsNull" /* IsNull */);
+    return new _Expr(ExprData.UnOp("IsNull" /* IsNull */, this.expr));
   }
   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);
+  isIn(that) {
+    return new _Expr(ExprData.BinOp("In" /* In */, this.expr, toExpr(that)));
   }
-  is(that) {
-    if (that === null || that instanceof _Expr && isConstant(that.expr, null))
-      return this.isNull();
-    return binop(this, "Equals" /* Equals */, that);
+  isNotIn(that) {
+    return new _Expr(ExprData.BinOp("NotIn" /* NotIn */, this.expr, toExpr(that)));
+  }
+  isGreater(that) {
+    return new _Expr(ExprData.BinOp("Greater" /* Greater */, this.expr, toExpr(that)));
   }
-  in(that) {
-    return binop(this, "In" /* In */, that);
+  isGreaterOrEqual(that) {
+    return new _Expr(
+      ExprData.BinOp("GreaterOrEqual" /* GreaterOrEqual */, this.expr, toExpr(that))
+    );
   }
-  notIn(that) {
-    return binop(this, "NotIn" /* NotIn */, that);
+  isLess(that) {
+    return new _Expr(ExprData.BinOp("Less" /* Less */, this.expr, toExpr(that)));
+  }
+  isLessOrEqual(that) {
+    return new _Expr(
+      ExprData.BinOp("LessOrEqual" /* LessOrEqual */, this.expr, toExpr(that))
+    );
   }
   add(that) {
-    return binop(this, "Add" /* Add */, that);
+    return new _Expr(ExprData.BinOp("Add" /* Add */, this.expr, toExpr(that)));
   }
   substract(that) {
-    return binop(this, "Subt" /* Subt */, that);
+    return new _Expr(ExprData.BinOp("Subt" /* Subt */, this.expr, toExpr(that)));
   }
   multiply(that) {
-    return binop(this, "Mult" /* Mult */, that);
+    return new _Expr(ExprData.BinOp("Mult" /* Mult */, this.expr, toExpr(that)));
   }
   remainder(that) {
-    return binop(this, "Mod" /* Mod */, that);
+    return new _Expr(ExprData.BinOp("Mod" /* Mod */, this.expr, toExpr(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);
+    return new _Expr(ExprData.BinOp("Div" /* Div */, this.expr, toExpr(that)));
   }
   concat(that) {
-    return binop(this, "Concat" /* Concat */, that);
+    return new _Expr(ExprData.BinOp("Concat" /* Concat */, this.expr, toExpr(that)));
   }
   like(that) {
-    return binop(this, "Like" /* Like */, that);
+    return new _Expr(ExprData.BinOp("Like" /* Like */, this.expr, toExpr(that)));
   }
   glob(that) {
-    return binop(this, "Glob" /* Glob */, that);
+    return new _Expr(ExprData.BinOp("Glob" /* Glob */, this.expr, toExpr(that)));
   }
   match(that) {
-    return binop(this, "Match" /* Match */, that);
+    return new _Expr(ExprData.BinOp("Match" /* Match */, this.expr, toExpr(that)));
   }
   with(that) {
     return new _Expr(
@@ -240,6 +246,9 @@ var _Expr = class {
   at(index) {
     return this.get(`[${Number(index)}]`);
   }
+  includes(value) {
+    return _Expr.create(value).isIn(this);
+  }
   filter(fn) {
     const alias = `__${Math.random().toString(36).slice(2, 9)}`;
     const target = Target.Expr(this.expr, alias);
@@ -268,13 +277,8 @@ var _Expr = class {
   }
 };
 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)));
-}
+__publicField(Expr, "NULL", _Expr.create(null));
+__publicField(Expr, "toExpr", Symbol("toExpr"));
 export {
   BinOpType,
   Expr,

package/dist/define/Fields.d.ts

@@ -1,10 +1,10 @@
-import { Column, PrimaryKey } from './Column';
+import { OptionalColumn, PrimaryColumn, 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 Field<T> = [T] extends [Array<any>] ? Expr<T> : [T] extends [PrimaryColumn<infer V, infer K>] ? Expr<PrimaryKey<V, K>> : [T] extends [OptionalColumn<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;

package/dist/define/Ops.d.ts

@@ -1,5 +1,7 @@
 import { Cursor } from './Cursor';
+import { Selection } from './Selection';
 import { Table } from './Table';
+export declare function select<X extends Selection>(selection: X): Cursor.SelectMultiple<Selection.Infer<X>>;
 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>;

package/dist/define/Ops.js

@@ -3,9 +3,17 @@ import { Cursor } from "./Cursor.js";
 import { ExprData } from "./Expr.js";
 import { Query } from "./Query.js";
 import { Schema } from "./Schema.js";
+import { table as createTable } from "./Table.js";
 import { Target } from "./Target.js";
+function select(selection) {
+  return new Cursor.SelectMultiple(
+    Query.Select({
+      selection: ExprData.create(selection)
+    })
+  );
+}
 function from(source) {
-  const target = "schema" in source ? Target.Table(source.schema()) : Target.Query(source.query());
+  const target = source instanceof Cursor ? Target.Query(source.query()) : Target.Table(source[createTable.data]);
   return new Cursor.SelectMultiple(
     Query.Select({
       from: target,
@@ -14,17 +22,17 @@ function from(source) {
   );
 }
 function update(table) {
-  return new Cursor.Update(Query.Update({ table: table.schema() }));
+  return new Cursor.Update(Query.Update({ table: table[createTable.data] }));
 }
 function insertInto(table) {
-  return new Cursor.Insert(table.schema());
+  return new Cursor.Insert(table[createTable.data]);
 }
 function deleteFrom(table) {
-  return new Cursor.Delete(Query.Delete({ table: table.schema() }));
+  return new Cursor.Delete(Query.Delete({ table: table[createTable.data] }));
 }
 function create(...tables) {
   return new Cursor.Batch(
-    tables.flatMap((table) => Schema.create(table.schema()).queries)
+    tables.flatMap((table) => Schema.create(table[createTable.data]).queries)
   );
 }
 export {
@@ -32,5 +40,6 @@ export {
   deleteFrom,
   from,
   insertInto,
+  select,
   update
 };

package/dist/define/Query.d.ts

@@ -2,7 +2,7 @@ import { ColumnData } from './Column';
 import { ExprData } from './Expr';
 import { IndexData } from './Index';
 import { OrderBy } from './OrderBy';
-import { Schema } from './Schema';
+import { TableData } from './Table';
 import { Target } from './Target';
 export declare enum QueryType {
     Insert = "Insert",
@@ -10,14 +10,15 @@ export declare enum QueryType {
     Update = "Update",
     Delete = "Delete",
     CreateTable = "CreateTable",
+    AlterTable = "AlterTable",
+    DropTable = "DropTable",
     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 type Query<T = any> = Query.Insert | Query.Select | Query.Update | Query.Delete | Query.CreateTable | Query.AlterTable | Query.DropTable | Query.CreateIndex | Query.DropIndex | Query.Batch | Query.Transaction | Query.Raw;
 export declare namespace Query {
     interface QueryBase {
         limit?: number;
@@ -33,43 +34,65 @@ export declare namespace Query {
     }
     interface Insert extends QueryBase {
         type: QueryType.Insert;
-        into: Schema;
-        data: Array<any>;
+        into: TableData;
+        data?: Array<any>;
+        select?: Query.Select;
     }
     function Insert(insert: Omit<Insert, 'type'>): Query.Insert;
     interface Select extends QueryBase {
         type: QueryType.Select;
         selection: ExprData;
-        from: Target;
+        from?: Target;
     }
     function Select(select: Omit<Select, 'type'>): Query.Select;
     interface Update extends QueryBase {
         type: QueryType.Update;
-        table: Schema;
+        table: TableData;
         set?: Record<string, any>;
     }
     function Update(update: Omit<Update, 'type'>): Query.Update;
     interface Delete extends QueryBase {
         type: QueryType.Delete;
-        table: Schema;
+        table: TableData;
     }
     function Delete(del: Omit<Delete, 'type'>): Query.Delete;
     interface CreateTable extends QueryBase {
         type: QueryType.CreateTable;
-        table: Schema;
+        table: TableData;
         ifNotExists?: boolean;
     }
     function CreateTable(create: Omit<CreateTable, 'type'>): Query.CreateTable;
+    interface AlterTable extends QueryBase {
+        type: QueryType.AlterTable;
+        table: TableData;
+        alterColumn?: ColumnData;
+        renameColumn?: {
+            from: string;
+            to: string;
+        };
+        addColumn?: ColumnData;
+        dropColumn?: string;
+        renameTable?: {
+            from: string;
+        };
+    }
+    function AlterTable(alter: Omit<AlterTable, 'type'>): Query.AlterTable;
+    interface DropTable extends QueryBase {
+        type: QueryType.DropTable;
+        table: TableData;
+        ifExists?: boolean;
+    }
+    function DropTable(drop: Omit<DropTable, 'type'>): Query.DropTable;
     interface CreateIndex extends QueryBase {
         type: QueryType.CreateIndex;
-        table: Schema;
+        table: TableData;
         index: IndexData;
         ifNotExists?: boolean;
     }
     function CreateIndex(create: Omit<CreateIndex, 'type'>): Query.CreateIndex;
     interface DropIndex extends QueryBase {
         type: QueryType.DropIndex;
-        table: Schema;
+        table: TableData;
         name: string;
         ifExists?: boolean;
     }
@@ -98,12 +121,4 @@ export declare namespace Query {
         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/define/Query.js

@@ -5,9 +5,10 @@ var QueryType = /* @__PURE__ */ ((QueryType2) => {
   QueryType2["Update"] = "Update";
   QueryType2["Delete"] = "Delete";
   QueryType2["CreateTable"] = "CreateTable";
+  QueryType2["AlterTable"] = "AlterTable";
+  QueryType2["DropTable"] = "DropTable";
   QueryType2["CreateIndex"] = "CreateIndex";
   QueryType2["DropIndex"] = "DropIndex";
-  QueryType2["AlterTable"] = "AlterTable";
   QueryType2["Batch"] = "Batch";
   QueryType2["Transaction"] = "Transaction";
   QueryType2["Raw"] = "Raw";
@@ -35,6 +36,14 @@ var Query;
     return { type: "CreateTable" /* CreateTable */, ...create };
   }
   Query2.CreateTable = CreateTable;
+  function AlterTable(alter) {
+    return { type: "AlterTable" /* AlterTable */, ...alter };
+  }
+  Query2.AlterTable = AlterTable;
+  function DropTable(drop) {
+    return { type: "DropTable" /* DropTable */, ...drop };
+  }
+  Query2.DropTable = DropTable;
   function CreateIndex(create) {
     return { type: "CreateIndex" /* CreateIndex */, ...create };
   }
@@ -63,10 +72,6 @@ var Query;
     return { type: "Raw" /* Raw */, ...raw };
   }
   Query2.Raw = Raw;
-  function AlterTable(alter) {
-    return { type: "AlterTable" /* AlterTable */, ...alter };
-  }
-  Query2.AlterTable = AlterTable;
 })(Query || (Query = {}));
 export {
   Query,

package/dist/define/Schema.d.ts

@@ -1,18 +1,11 @@
 import { Formatter } from '../lib/Formatter';
-import { ColumnData } from './Column';
-import { IndexData } from './Index';
 import { Query } from './Query';
-export interface Schema {
-    name: string;
-    alias?: string;
-    columns: Record<string, ColumnData>;
-    indexes: Record<string, IndexData>;
-}
+import { TableData } from './Table';
 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>;
+    function create(schema: TableData): Query.Batch;
+    function upgrade(formatter: Formatter, local: SchemaInstructions, schema: TableData): Array<Query>;
 }