rado 0.1.64 → 0.2.1

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,38 +122,52 @@ 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();
     }
     leftJoin(that, ...on) {
       const query = this.query();
-      if (!query.from)
-        throw new Error("No from clause");
       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();
-      if (!query.from)
-        throw new Error("No from clause");
       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) {
@@ -189,41 +216,81 @@ 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();
     }
     leftJoin(that, ...on) {
       const query = this.query();
-      if (!query.from)
-        throw new Error("No from clause");
       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();
-      if (!query.from)
-        throw new Error("No from clause");
       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) {
@@ -256,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>;

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))
@@ -277,7 +277,8 @@ var _Expr = class {
   }
 };
 var Expr = _Expr;
-__publicField(Expr, "NULL", toExpr(null));
+__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.js

@@ -3,6 +3,7 @@ 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(
@@ -12,7 +13,7 @@ function select(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,
@@ -21,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 {

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,8 +34,9 @@ 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 {
@@ -45,31 +47,52 @@ export declare namespace Query {
     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>;
 }

package/dist/define/Schema.js

@@ -1,25 +1,63 @@
 // src/define/Schema.ts
 import { Statement } from "../lib/Statement.js";
-import { Query } from "./Query.js";
+import { Expr, ExprData } from "./Expr.js";
+import { Query, QueryType } from "./Query.js";
+import { Target } from "./Target.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 }));
+    const meta = schema.meta();
+    if (meta.indexes)
+      for (const index of Object.values(meta.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 recreateTable(table, addedColumns) {
+    const queries = [];
+    const tempTable = { ...table, name: `$$new_${table.name}` };
+    queries.push(Query.CreateTable({ table: tempTable }));
+    queries.push(
+      Query.Insert({
+        into: tempTable,
+        select: Query.Select({
+          from: Target.Table(table),
+          selection: ExprData.Record(
+            Object.fromEntries(
+              Object.entries(table.columns).map(([key, column]) => [
+                key,
+                addedColumns.has(key) ? (typeof column.defaultValue === "function" ? column.defaultValue() : column.defaultValue) || Expr.NULL.expr : ExprData.Field(ExprData.Row(Target.Table(table)), key)
+              ])
+            )
+          )
+        })
+      })
+    );
+    queries.push(Query.DropTable({ table, ifExists: true }));
+    queries.push(
+      Query.AlterTable({
+        table,
+        renameTable: { from: tempTable.name }
+      })
+    );
+    for (const index of Object.values(table.meta().indexes))
+      queries.push(Query.CreateIndex({ table, index }));
+    return queries;
+  }
   function upgrade(formatter, local, schema) {
     const columnNames = /* @__PURE__ */ new Set([
       ...Object.keys(local.columns),
       ...Object.keys(schema.columns)
     ]);
     const res = [];
+    let recreate = false;
     for (const columnName of columnNames) {
       const localInstruction = local.columns[columnName];
       const schemaCol = schema.columns[columnName];
@@ -33,17 +71,24 @@ var Schema;
           { ...schemaCol, references: void 0 }
         );
         if (removeLeadingWhitespace(localInstruction) !== removeLeadingWhitespace(instruction)) {
-          res.push(Query.AlterTable({ table: schema, alterColumn: schemaCol }));
+          recreate = true;
         }
       }
     }
+    if (recreate) {
+      const added = res.filter(
+        (query) => query.type === QueryType.AlterTable && Boolean(query.addColumn)
+      ).map((query) => query.addColumn.name);
+      return recreateTable(schema, new Set(added));
+    }
+    const meta = schema.meta();
     const indexNames = /* @__PURE__ */ new Set([
       ...Object.keys(local.indexes),
-      ...Object.keys(schema.indexes)
+      ...Object.keys(meta.indexes)
     ]);
     for (const indexName of indexNames) {
       const localInstruction = local.indexes[indexName];
-      const schemaIndex = schema.indexes[indexName];
+      const schemaIndex = meta.indexes[indexName];
       if (!localInstruction) {
         res.push(Query.CreateIndex({ table: schema, index: schemaIndex }));
       } else if (!schemaIndex) {

package/dist/define/Selection.d.ts

@@ -1,6 +1,6 @@
 import type { Cursor } from './Cursor';
 import type { Expr } from './Expr';
-type SelectionBase = (() => any) | Expr<any> | Cursor.SelectMultiple<any> | Cursor.SelectSingle<any>;
+type SelectionBase = unknown | (() => any) | Expr<any> | Cursor.SelectMultiple<any> | Cursor.SelectSingle<any>;
 interface SelectionRecord extends Record<string, Selection> {
 }
 export type Selection = SelectionBase | SelectionRecord;
@@ -12,8 +12,8 @@ export declare namespace Selection {
     } ? K : T extends {
         [__cursorType](): infer K;
     } ? K : T extends Expr<infer K> ? K : T extends Record<string, Selection> ? {
-        [K in keyof T as T[K] extends () => any ? never : K]: Infer<T[K]>;
-    } : T extends () => any ? never : T;
+        [K in keyof T]: Infer<T[K]>;
+    } : T extends () => any ? never : unknown extends T ? never : T;
     type With<A, B> = Expr<Combine<A, B>>;
     type Combine<A, B> = Omit<A, keyof Infer<B>> & Infer<B>;
 }