rado 0.1.63 → 0.2.0

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>;
 }

package/dist/define/Table.d.ts

@@ -1,62 +1,67 @@
-import { Column, PrimaryKey } from './Column';
+import { Column, ColumnData, OptionalColumn, PrimaryColumn } from './Column';
 import { Cursor } from './Cursor';
-import { EV, Expr } from './Expr';
-import { Fields } from './Fields';
-import { Index } from './Index';
-import { Schema } from './Schema';
+import { EV } from './Expr';
+import { Index, IndexData } from './Index';
 import { Selection } from './Selection';
-import { Update } from './Update';
-export declare class Table<T> extends Cursor.SelectMultiple<Table.Normalize<T>> {
-    [Selection.__tableType](): Table.Normalize<T>;
-    constructor(schema: Schema);
-    fetch(id: EV<T extends {
-        id: Column.IsPrimary<infer V, any>;
-    } ? V : never>): Cursor.SelectSingle<Table.Normalize<T> | undefined>;
-    insertOne(record: Table.Insert<T>): Cursor<Table.Normalize<T>>;
-    insertAll(data: Array<Table.Insert<T>>): Cursor.InsertValues;
-    set(data: Update<Table.Normalize<T>>): Cursor.Update<Table.Normalize<T>>;
-    delete(): Cursor.Delete;
-    createTable(): Cursor.CreateTable;
-    as(alias: string): this;
-    alias(): Record<string, this>;
-    get(name: string): Expr<any>;
-    toExpr(): Expr<Table.Normalize<T>>;
-    schema(): Schema;
+interface TableDefinition {
 }
+export interface TableData {
+    name: string;
+    alias?: string;
+    definition: TableDefinition;
+    columns: Record<string, ColumnData>;
+    meta(): {
+        indexes: Record<string, IndexData>;
+    };
+}
+interface TableProto<Definition> {
+    (conditions: {
+        [K in keyof Definition]?: Definition[K] extends Column<infer V> ? EV<V> : never;
+    }): Cursor.TableSelect<Definition>;
+    (...conditions: Array<EV<boolean>>): Cursor.TableSelect<Definition>;
+}
+declare class TableProto<Definition> {
+    [Selection.__tableType](): Table.Select<Definition>;
+    get [table.data](): TableData;
+    [table.meta](): TableMeta;
+    get name(): unknown;
+    get length(): unknown;
+    get call(): unknown;
+    get apply(): unknown;
+    get bind(): unknown;
+    get prototype(): unknown;
+}
+export type Table<Definition> = Definition & TableProto<Definition>;
 export declare namespace Table {
-    type Intersection<A, B> = A & B extends infer U ? {
-        [P in keyof U]: EV<U[P]>;
-    } : never;
-    type OptionalKeys<T> = {
-        [K in keyof T]: null extends T[K] ? K : T[K] extends Column.IsPrimary<any, any> ? K : T[K] extends Column.IsOptional<any> ? K : never;
-    }[keyof T];
-    type RequiredKeys<T> = {
-        [K in keyof T]: null extends T[K] ? never : T[K] extends Column.IsPrimary<any, any> ? never : T[K] extends Column.IsOptional<any> ? never : K;
-    }[keyof T];
-    type Optionals<T> = {
-        [K in keyof T]?: T[K] extends Column.IsOptional<infer V> ? V : T[K] extends Column.IsPrimary<infer V, infer K> ? PrimaryKey<V, K> : T[K];
+    export type Select<Definition> = {
+        [K in keyof Definition as Definition[K] extends Column<any> ? K : never]: Definition[K] extends Column<infer T> ? T : never;
     };
-    export type Insert<T> = Intersection<Optionals<Pick<T, OptionalKeys<T>>>, Pick<T, RequiredKeys<T>>>;
-    export type Normalize<T> = {
-        [K in keyof T]: T[K] extends Column.IsOptional<infer V> ? V : T[K] extends Column.IsPrimary<infer V, infer K> ? PrimaryKey<V, K> : T[K];
+    export type Update<Definition> = Partial<{
+        [K in keyof Definition as Definition[K] extends Column<any> ? K : never]: Definition[K] extends Column<infer T> ? EV<T> : never;
+    }>;
+    type IsOptional<K> = K extends PrimaryColumn<any, any> ? true : K extends OptionalColumn<any> ? true : K extends Column<infer V> ? null extends V ? true : false : never;
+    export type Insert<Definition> = {
+        [K in keyof Definition as true extends IsOptional<Definition[K]> ? K : never]?: Definition[K] extends Column<infer V> ? EV<V> : never;
+    } & {
+        [K in keyof Definition as false extends IsOptional<Definition[K]> ? K : never]: Definition[K] extends Column<infer V> ? EV<V> : never;
     };
-    export type Infer<T> = T extends Table<infer U> ? Normalize<U> : never;
     export {};
 }
-export type TableOptions<T, R> = {
-    name: string;
-    alias?: string;
-    columns: {
-        [K in keyof T]: Column<T[K]>;
-    };
-    indexes?: (this: Fields<T>) => Record<string, Index>;
+export interface TableMeta {
+    indexes?: Record<string, Index>;
+}
+type Definition<T> = {
+    [K in keyof T as K extends string ? K : never]: Column<any> | (() => any);
 };
-export declare function table<T extends {}, R>(options: TableOptions<T, R>): Table<T> & Fields<T>;
+interface Define<T> {
+    new (): T;
+}
+type Blueprint<T> = Definition<T>;
+export type table<T> = T extends Table<infer D> ? Table.Select<D> : never;
+export declare function createTable<Definition>(data: TableData): Table<Definition>;
+export declare function table<T extends Blueprint<T>>(define: Record<string, T | Define<T>>): Table<T>;
 export declare namespace table {
-    export type infer<T> = Table.Infer<T>;
-    type Extensions<T> = {
-        [key: string]: (this: T, ...args: any[]) => any;
-    };
-    export function extend<T extends Table<any>, E extends Extensions<T>>(target: T, extensions: E): T & E;
-    export {};
+    const data: unique symbol;
+    const meta: unique symbol;
 }
+export {};

package/dist/define/Table.js

@@ -1,130 +1,173 @@
 // src/define/Table.ts
+import { Column } from "./Column.js";
 import { Cursor } from "./Cursor.js";
-import { Expr, ExprData } from "./Expr.js";
-import { Query } from "./Query.js";
+import { BinOpType, Expr, ExprData } from "./Expr.js";
 import { Selection } from "./Selection.js";
 import { Target } from "./Target.js";
-var Table = class extends Cursor.SelectMultiple {
+var {
+  keys,
+  entries,
+  fromEntries,
+  getOwnPropertyDescriptors,
+  assign,
+  getPrototypeOf,
+  setPrototypeOf,
+  getOwnPropertyDescriptor
+} = Object;
+var { ownKeys } = Reflect;
+var TableProto = class {
   [Selection.__tableType]() {
     throw "assert";
   }
-  constructor(schema) {
-    super(
-      Query.Select({
-        from: Target.Table(schema),
-        selection: ExprData.Row(Target.Table(schema))
-      })
-    );
-    Object.defineProperty(this, "schema", {
-      enumerable: false,
-      value: () => schema
-    });
-    if (schema.columns)
-      for (const column of Object.keys(schema.columns)) {
-        Object.defineProperty(this, column, {
-          enumerable: true,
-          get: () => this.get(column)
-        });
-      }
-    return new Proxy(this, {
-      get(target, key) {
-        return key in target ? target[key] : target.get(key);
-      }
-    });
-  }
-  fetch(id) {
-    return this.where(this.get("id").is(id)).first();
-  }
-  insertOne(record) {
-    return new Cursor(
-      Query.Insert({
-        into: this.schema(),
-        data: [record],
-        selection: ExprData.Row(Target.Table(this.schema())),
-        singleResult: true
-      })
-    );
+  get [table.data]() {
+    throw "assert";
   }
-  insertAll(data) {
-    return new Cursor.Insert(this.schema()).values(...data);
+  [table.meta]() {
+    throw "assert";
   }
-  set(data) {
-    return new Cursor.Update(
-      Query.Update({
-        table: this.schema()
-      })
-    ).set(data);
+  // Clear the Function prototype, not sure if there's a better way
+  // as mapped types (Omit) will remove the callable signature. We define them
+  // in a class getter since it's the only way to also mark them as non-enumarable
+  // Seems open: Microsoft/TypeScript#27575
+  get name() {
+    throw "assert";
   }
-  delete() {
-    return new Cursor.Delete(Query.Delete({ table: this.schema() }));
+  get length() {
+    throw "assert";
   }
-  createTable() {
-    return new Cursor.CreateTable(this.schema());
+  get call() {
+    throw "assert";
   }
-  as(alias) {
-    return new Table({ ...this.schema(), alias });
+  get apply() {
+    throw "assert";
   }
-  alias() {
-    return new Proxy(
-      {},
-      {
-        get: (_, key) => {
-          return this.as(key);
-        }
-      }
-    );
+  get bind() {
+    throw "assert";
   }
-  get(name) {
-    return new Expr(ExprData.Field(this.toExpr().expr, name));
+  get prototype() {
+    throw "assert";
   }
-  toExpr() {
-    return new Expr(
-      ExprData.Row(Target.Table(this.schema()))
-    );
+};
+function keysOf(input) {
+  const methods = [];
+  while (input = getPrototypeOf(input)) {
+    const keys2 = ownKeys(input);
+    for (const key of keys2)
+      if (typeof key === "string")
+        methods.push(key);
   }
-  schema() {
-    throw new Error("Not implemented");
+  return methods;
+}
+function createTable(data) {
+  const target = Target.Table(data);
+  const call = {
+    [data.name]: function(...args) {
+      const isConditionalRecord = args.length === 1 && typeof args[0] === "object" && !(args[0] instanceof Expr);
+      const conditions = isConditionalRecord ? entries(args[0]).map(([key, value]) => {
+        const column = data.columns[key];
+        if (!column)
+          throw new Error(`Column ${key} not found`);
+        return new Expr(
+          ExprData.BinOp(
+            BinOpType.Equals,
+            ExprData.Field(ExprData.Row(target), key),
+            ExprData.create(value)
+          )
+        );
+      }) : args;
+      return new Cursor.TableSelect(data, conditions);
+    }
+  }[data.name];
+  const cols = keys(data.columns);
+  const hasKeywords = cols.concat(keysOf(data.definition)).some((name) => name in Function);
+  const expressions = fromEntries(
+    cols.map((name) => [
+      name,
+      new Expr(ExprData.Field(ExprData.Row(target), name))
+    ])
+  );
+  const toExpr = () => new Expr(ExprData.Row(target));
+  const ownKeys2 = ["prototype", ...cols];
+  let res;
+  if (!hasKeywords) {
+    res = assign(call, expressions, { [table.data]: data });
+    setPrototypeOf(call, getPrototypeOf(data.definition));
+  } else {
+    let get2 = function(key) {
+      return expressions[key] || data.definition[key];
+    };
+    var get = get2;
+    res = new Proxy(call, {
+      get(target2, key) {
+        if (key === table.data)
+          return data;
+        if (key === Expr.toExpr)
+          return toExpr;
+        return get2(key);
+      },
+      ownKeys(target2) {
+        return ownKeys2;
+      },
+      getOwnPropertyDescriptor(target2, key) {
+        if (key === "prototype")
+          return getOwnPropertyDescriptor(target2, key);
+        return {
+          value: get2(key),
+          enumerable: true,
+          configurable: true
+        };
+      }
+    });
   }
-};
-function table(options) {
-  const schema = {
-    ...options,
-    columns: Object.fromEntries(
-      Object.entries(options.columns).map(([key, column]) => {
+  return res;
+}
+function table(define) {
+  const names = keys(define);
+  if (names.length !== 1)
+    throw new Error("Table must have a single name");
+  const name = names[0];
+  const target = define[name];
+  const definition = "prototype" in target ? new target() : target;
+  const columns = definition;
+  const res = createTable({
+    name,
+    definition,
+    columns: fromEntries(
+      entries(getOwnPropertyDescriptors(columns)).map(([name2, descriptor]) => {
+        const column = columns[name2];
+        if (!(column instanceof Column))
+          throw new Error(`Property ${name2} is not a column`);
         const { data } = column;
-        return [key, { ...data, name: data.name || key }];
+        return [
+          name2,
+          {
+            ...data,
+            name: data.name || name2,
+            enumerable: descriptor.enumerable
+          }
+        ];
       })
     ),
-    indexes: {}
-  };
-  const indexes = Object.fromEntries(
-    Object.entries(
-      options.indexes ? options.indexes.call(
-        new Expr(ExprData.Row(Target.Table(schema)))
-      ) : {}
-    ).map(([key, index]) => {
-      const indexName = `${schema.name}.${key}`;
-      return [indexName, { name: indexName, ...index.data }];
-    })
-  );
-  return new Table({
-    ...schema,
-    indexes
+    meta() {
+      const createMeta = res[table.meta];
+      const meta = createMeta ? createMeta.apply(res) : {};
+      return {
+        indexes: fromEntries(
+          entries(meta?.indexes || {}).map(([key, index]) => {
+            const indexName = `${name}.${key}`;
+            return [indexName, { name: indexName, ...index.data }];
+          })
+        )
+      };
+    }
   });
+  return res;
 }
 ((table2) => {
-  function extend(target, extensions) {
-    return new Proxy(target, {
-      get(target2, key) {
-        if (key === "as")
-          return (...args) => extend(target2.as(...args), extensions);
-        return key in extensions ? extensions[key].bind(target2) : target2[key];
-      }
-    });
-  }
-  table2.extend = extend;
+  table2.data = Symbol("data");
+  table2.meta = Symbol("meta");
 })(table || (table = {}));
 export {
-  Table,
+  createTable,
   table
 };

package/dist/define/Target.d.ts

@@ -1,6 +1,6 @@
 import { ExprData } from './Expr';
 import { Query as QueryData } from './Query';
-import { Schema } from './Schema';
+import { TableData } from './Table';
 export declare enum TargetType {
     Expr = "Expr",
     Query = "Query",
@@ -23,9 +23,9 @@ export declare namespace Target {
     function Query(query: QueryData, alias?: string): Query;
     interface Table {
         type: TargetType.Table;
-        table: Schema;
+        table: TableData;
     }
-    function Table(table: Schema): Table;
+    function Table(table: TableData): Table;
     interface Join {
         type: TargetType.Join;
         left: Target;
@@ -34,5 +34,5 @@ export declare namespace Target {
         on: ExprData;
     }
     function Join(left: Target, right: Target, joinType: 'left' | 'inner', on: ExprData): Join;
-    function source(from: Target): Schema | undefined;
+    function source(from: Target): TableData | undefined;
 }

package/dist/lib/Callable.d.ts

@@ -0,0 +1,3 @@
+export declare class Callable extends Function {
+    constructor(fn: Function);
+}

package/dist/lib/Callable.js

@@ -0,0 +1,14 @@
+// src/lib/Callable.ts
+var Callable = class extends Function {
+  constructor(fn) {
+    super();
+    return new Proxy(this, {
+      apply(_, thisArg, input) {
+        return fn.apply(thisArg, input);
+      }
+    });
+  }
+};
+export {
+  Callable
+};

package/dist/lib/Driver.js

@@ -4,6 +4,7 @@ import { Expr, ExprData } from "../define/Expr.js";
 import { ParamData } from "../define/Param.js";
 import { Query, QueryType } from "../define/Query.js";
 import { Schema } from "../define/Schema.js";
+import { table } from "../define/Table.js";
 var Callable = class extends Function {
   constructor(fn) {
     super();
@@ -80,8 +81,8 @@ var SyncDriver = class extends DriverBase {
   }
   migrateSchema(...tables) {
     const queries = [];
-    for (const table of Object.values(tables)) {
-      const schema = table.schema();
+    for (const current of Object.values(tables)) {
+      const schema = current[table.data];
       const localSchema = this.schemaInstructions(schema.name);
       if (!localSchema) {
         queries.push(...Schema.create(schema).queries);
@@ -186,8 +187,8 @@ var AsyncDriver = class extends DriverBase {
   }
   async migrateSchema(...tables) {
     const queries = [];
-    for (const table of Object.values(tables)) {
-      const schema = table.schema();
+    for (const current of Object.values(tables)) {
+      const schema = current[table.data];
       const localSchema = await this.schemaInstructions(schema.name);
       if (!localSchema) {
         queries.push(...Schema.create(schema).queries);

package/dist/lib/Formatter.d.ts

@@ -22,6 +22,7 @@ export interface FormatContext {
     formatAsInsert?: boolean;
     formatAsIn?: boolean;
     topLevel?: boolean;
+    selectAsColumns?: boolean;
 }
 type FormatSubject = (stmt: Statement, mkSubject: () => void) => void;
 export interface CompileOptions extends Partial<FormatContext>, StatementOptions {
@@ -43,6 +44,7 @@ export declare abstract class Formatter implements Sanitizer {
         formatAsInsert?: boolean | undefined;
         formatAsIn?: boolean | undefined;
         topLevel?: boolean | undefined;
+        selectAsColumns?: boolean | undefined;
         skipNewlines?: boolean | undefined;
     };
     format<T>(ctx: FormatContext, query: Query<T>): Statement;
@@ -54,6 +56,7 @@ export declare abstract class Formatter implements Sanitizer {
     formatCreateIndex(ctx: FormatContext, query: Query.CreateIndex): Statement;
     formatDropIndex(ctx: FormatContext, query: Query.DropIndex): Statement;
     formatAlterTable(ctx: FormatContext, query: Query.AlterTable): Statement;
+    formatDropTable(ctx: FormatContext, query: Query.DropTable): Statement;
     formatTransaction(ctx: FormatContext, { op, id }: Query.Transaction): Statement;
     formatBatch(ctx: FormatContext, { queries }: Query.Batch): Statement;
     formatRaw(ctx: FormatContext, { strings, params }: Query.Raw): Statement;