rado 0.1.64 → 0.2.1

package/dist/define/Table.d.ts

@@ -1,62 +1,70 @@
-import { Column, PrimaryKey } from './Column';
+import { Column, ColumnData, OptionalColumn, PrimaryColumn, PrimaryKey } 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 Of<Row> = Table<{
+        [K in keyof Row]: Column<Row[K]>;
+    }>;
+    export type Select<Definition> = {
+        [K in keyof Definition as Definition[K] extends Column<any> ? K : never]: Definition[K] extends PrimaryColumn<infer T, infer K> ? PrimaryKey<T, K> : 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,175 @@
 // 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/index.d.ts

@@ -13,7 +13,6 @@ export * from './define/Schema';
 export * from './define/Selection';
 export * from './define/Table';
 export * from './define/Target';
-export * from './define/Update';
 export type { Driver } from './lib/Driver';
 export type { FormatContext, Formatter } from './lib/Formatter';
 export type { Sanitizer } from './lib/Sanitizer';

package/dist/index.js

@@ -14,5 +14,4 @@ export * from "./define/Schema.js";
 export * from "./define/Selection.js";
 export * from "./define/Table.js";
 export * from "./define/Target.js";
-export * from "./define/Update.js";
 export * from "./lib/SqlError.js";

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;

package/dist/lib/Formatter.js

@@ -61,12 +61,14 @@ var Formatter = class {
         return this.formatDelete(ctx, query);
       case QueryType.CreateTable:
         return this.formatCreateTable(ctx, query);
+      case QueryType.AlterTable:
+        return this.formatAlterTable(ctx, query);
+      case QueryType.DropTable:
+        return this.formatDropTable(ctx, query);
       case QueryType.CreateIndex:
         return this.formatCreateIndex(ctx, query);
       case QueryType.DropIndex:
         return this.formatDropIndex(ctx, query);
-      case QueryType.AlterTable:
-        return this.formatAlterTable(ctx, query);
       case QueryType.Transaction:
         return this.formatTransaction(ctx, query);
       case QueryType.Batch:
@@ -96,18 +98,28 @@ var Formatter = class {
   }
   formatInsert(ctx, query) {
     const { stmt } = ctx;
-    const columns = Object.values(query.into.columns);
+    const columns = Object.values(query.into.columns).map((c) => c.name);
     stmt.add("INSERT INTO").addIdentifier(query.into.name);
     if (query.into.alias)
       stmt.raw("AS").addIdentifier(query.into.alias);
     for (const column of stmt.call(columns))
-      this.formatString(ctx, column.name);
-    stmt.add("VALUES");
-    if (query.data.length === 0)
-      stmt.add("()");
-    else
+      this.formatString(ctx, column);
+    if (query.data) {
+      stmt.add("VALUES").space();
       for (const row of stmt.separate(query.data))
         this.formatInsertRow(ctx, query.into.columns, row);
+    }
+    if (query.select) {
+      stmt.space();
+      this.formatSelect(
+        {
+          ...ctx,
+          topLevel: false,
+          selectAsColumns: true
+        },
+        query.select
+      );
+    }
     if (query.selection) {
       stmt.add("RETURNING").space();
       this.formatSelection(ctx, query.selection, formatAsResultObject);
@@ -183,17 +195,33 @@ var Formatter = class {
   }
   formatAlterTable(ctx, query) {
     const { stmt } = ctx;
-    stmt.add("ALTER TABLE").addIdentifier(query.table.name);
+    stmt.add("ALTER TABLE").addIdentifier(
+      query.renameTable ? query.renameTable.from : query.table.name
+    );
     if (query.addColumn) {
       stmt.add("ADD COLUMN").space();
       this.formatColumn(ctx, query.addColumn);
     } else if (query.dropColumn) {
       stmt.add("DROP COLUMN").addIdentifier(query.dropColumn);
+    } else if (query.renameColumn) {
+      stmt.add("RENAME COLUMN");
+      stmt.addIdentifier(query.renameColumn.from).add("TO");
+      stmt.addIdentifier(query.renameColumn.to);
+    } else if (query.renameTable) {
+      stmt.add("RENAME TO").addIdentifier(query.table.name);
     } else if (query.alterColumn) {
       throw new Error(`Not available in this formatter: alter column`);
     }
     return stmt;
   }
+  formatDropTable(ctx, query) {
+    const { stmt } = ctx;
+    stmt.add("DROP TABLE");
+    if (query.ifExists)
+      stmt.add("IF EXISTS");
+    stmt.addIdentifier(query.table.name);
+    return stmt;
+  }
   formatTransaction(ctx, { op, id }) {
     const { stmt } = ctx;
     switch (op) {
@@ -393,10 +421,10 @@ var Formatter = class {
     const { stmt, forceInline } = ctx;
     if (!limit && !offset && !singleResult)
       return stmt;
-    stmt.newline().raw("LIMIT");
+    stmt.newline().raw("LIMIT").space();
     this.formatValue(ctx, singleResult ? 1 : limit);
     if (offset && offset > 0) {
-      stmt.raw("OFFSET");
+      stmt.add("OFFSET").space();
       this.formatValue(ctx, offset);
     }
     return stmt;
@@ -414,7 +442,8 @@ var Formatter = class {
       formatSubject(stmt, mkSubject);
     else
       this.formatExpr(ctx, selection);
-    stmt.add("AS").addIdentifier("result");
+    if (!ctx.selectAsColumns)
+      stmt.add("AS").addIdentifier("result");
     return stmt;
   }
   formatExprJson(ctx, expr) {
@@ -579,12 +608,12 @@ var Formatter = class {
           return stmt.closeParenthesis();
         }
         if (expr.query.singleResult) {
-          stmt.raw("json").openParenthesis().openParenthesis();
-          this.format(ctx, expr.query);
-          return stmt.closeParenthesis().closeParenthesis();
+          stmt.openParenthesis();
+          this.format({ ...ctx, topLevel: true }, expr.query);
+          return stmt.closeParenthesis().raw(`->'$.result'`);
         }
-        stmt.openParenthesis().raw("SELECT json_group_array(json(result))").newline().raw("FROM").space().openParenthesis();
-        this.format(ctx, expr.query);
+        stmt.openParenthesis().raw(`SELECT json_group_array(result->'$.result')`).newline().raw("FROM").space().openParenthesis();
+        this.format({ ...ctx, topLevel: true }, expr.query);
         return stmt.closeParenthesis().closeParenthesis();
       case ExprType.Row:
         switch (expr.target.type) {
@@ -615,12 +644,21 @@ var Formatter = class {
         this.formatExpr({ ...ctx, formatAsJson: true }, expr.b);
         return stmt.closeParenthesis();
       case ExprType.Record:
-        stmt.identifier("json_object");
-        for (const [key, value] of stmt.call(Object.entries(expr.fields))) {
+        if (ctx.selectAsColumns) {
+          const inner = { ...ctx, selectAsColumns: false };
+          for (const [key, value] of stmt.separate(
+            Object.entries(expr.fields)
+          )) {
+            this.formatExprJson(inner, value);
+          }
+          return stmt;
+        }
+        stmt.identifier("json_object").openParenthesis();
+        for (const [key, value] of stmt.separate(Object.entries(expr.fields))) {
           this.formatString(ctx, key).raw(", ");
           this.formatExprJson(ctx, value);
         }
-        return stmt;
+        return stmt.closeParenthesis();
       case ExprType.Filter: {
         const { target, condition } = expr;
         switch (target.type) {