rado 0.1.22 → 0.1.23

package/README.md

@@ -1 +1 @@
-# rado
+# rado

package/dist/Column.d.ts

@@ -0,0 +1,41 @@
+export declare const enum ColumnType {
+    String = "String",
+    Integer = "Integer",
+    Number = "Number",
+    Boolean = "Boolean",
+    Json = "Json"
+}
+export interface ColumnData {
+    type: ColumnType;
+    name?: string;
+    nullable?: boolean;
+    defaultValue?: any;
+    autoIncrement?: boolean;
+    primaryKey?: boolean;
+    unique?: boolean;
+}
+export declare class Column<T = any> {
+    data: ColumnData;
+    constructor(data: ColumnData);
+    name(name: string): Column<T>;
+    nullable(): Column<T | null>;
+    autoIncrement(): Column<T & Column.Optional>;
+    primaryKey(): Column<T & Column.Optional>;
+    unique(): Column<T>;
+    defaultValue(value: T): Column<T & Column.Optional>;
+}
+export declare namespace Column {
+    const isOptional: unique symbol;
+    export type Optional = {
+        [isOptional]: true;
+    };
+    export {};
+}
+export declare const column: {
+    string<T extends string = string>(): Column<T>;
+    integer<T_1 extends number = number>(): Column<T_1>;
+    number<T_2 extends number = number>(): Column<T_2>;
+    boolean<T_3 extends boolean = boolean>(): Column<T_3>;
+    object<T_4 extends object = object>(): Column<T_4>;
+    array<T_5 = any>(): Column<T_5[]>;
+};

package/dist/Column.js

@@ -0,0 +1,58 @@
+// src/Column.ts
+var ColumnType = /* @__PURE__ */ ((ColumnType2) => {
+  ColumnType2["String"] = "String";
+  ColumnType2["Integer"] = "Integer";
+  ColumnType2["Number"] = "Number";
+  ColumnType2["Boolean"] = "Boolean";
+  ColumnType2["Object"] = "Object";
+  ColumnType2["Array"] = "Array";
+  return ColumnType2;
+})(ColumnType || {});
+var Column = class {
+  constructor(data) {
+    this.data = data;
+  }
+  name(name) {
+    return new Column({ ...this.data, name });
+  }
+  nullable() {
+    return new Column({ ...this.data, nullable: true });
+  }
+  autoIncrement() {
+    return new Column({ ...this.data, autoIncrement: true });
+  }
+  primaryKey() {
+    return new Column({ ...this.data, primaryKey: true });
+  }
+  unique() {
+    return new Column({ ...this.data, unique: true });
+  }
+  defaultValue(value) {
+    return new Column({ ...this.data, defaultValue: value });
+  }
+};
+var column = {
+  string() {
+    return new Column({ type: "String" /* String */ });
+  },
+  integer() {
+    return new Column({ type: "Integer" /* Integer */ });
+  },
+  number() {
+    return new Column({ type: "Number" /* Number */ });
+  },
+  boolean() {
+    return new Column({ type: "Boolean" /* Boolean */ });
+  },
+  object() {
+    return new Column({ type: "Object" /* Object */ });
+  },
+  array() {
+    return new Column({ type: "Array" /* Array */ });
+  }
+};
+export {
+  Column,
+  ColumnType,
+  column
+};

package/dist/Cursor.d.ts

@@ -0,0 +1,77 @@
+import { EV, Expr } from './Expr';
+import { OrderBy } from './OrderBy';
+import { Query } from './Query';
+import { Schema } from './Schema';
+import { Selection } from './Selection';
+import { Table } from './Table';
+import { Update as UpdateSet } from './Update';
+export declare class Cursor<T> {
+    /** @internal */
+    protected __cursorType: T;
+    constructor(query: Query<T>);
+    query(): Query<T>;
+    toJSON(): Query<T>;
+}
+export declare namespace Cursor {
+    class Limitable<T> extends Cursor<T> {
+        take(limit: number | undefined): Limitable<T>;
+        skip(offset: number | undefined): Limitable<T>;
+    }
+    class Filterable<T> extends Limitable<T> {
+        where(...where: Array<EV<boolean>>): Filterable<T>;
+    }
+    class Delete<T> extends Filterable<{
+        rowsAffected: number;
+    }> {
+        query(): Query.Delete;
+    }
+    class Update<T> extends Filterable<{
+        rowsAffected: number;
+    }> {
+        query: () => Query.Update;
+        set(set: UpdateSet<T>): Update<T>;
+    }
+    class InsertValuesReturning<T> extends Cursor<T> {
+    }
+    class InsertValues extends Cursor<{
+        rowsAffected: number;
+    }> {
+        query(): Query.Insert;
+        returning<X extends Selection>(selection: X): InsertValuesReturning<Selection.Infer<X>>;
+    }
+    class Insert<T> {
+        protected into: Schema;
+        constructor(into: Schema);
+        values(...data: Array<Table.Insert<T>>): InsertValues;
+    }
+    class Create extends Cursor<void> {
+        protected table: Schema;
+        constructor(table: Schema);
+    }
+    class Batch<T = void> extends Cursor<T> {
+        protected queries: Array<Query>;
+        constructor(queries: Array<Query>);
+    }
+    class SelectMultiple<T> extends Filterable<Array<T>> {
+        query(): Query.Select;
+        leftJoin<C>(that: Table<C>, ...on: Array<EV<boolean>>): SelectMultiple<T>;
+        innerJoin<C>(that: Table<C>, ...on: Array<EV<boolean>>): SelectMultiple<T>;
+        select<X extends Selection>(selection: X): SelectMultiple<Selection.Infer<X>>;
+        count(): SelectSingle<number>;
+        orderBy(...orderBy: Array<OrderBy>): SelectMultiple<T>;
+        groupBy(...groupBy: Array<Expr<any>>): SelectMultiple<T>;
+        first(): SelectSingle<T | undefined>;
+        where(...where: Array<EV<boolean>>): SelectMultiple<T>;
+        toExpr(): Expr<T>;
+    }
+    class SelectSingle<T> extends Filterable<T> {
+        query(): Query.Select;
+        leftJoin<C>(that: Table<C>, ...on: Array<EV<boolean>>): SelectSingle<T>;
+        innerJoin<C>(that: Table<C>, ...on: Array<EV<boolean>>): SelectSingle<T>;
+        select<X extends Selection>(selection: X): SelectSingle<Selection.Infer<X>>;
+        orderBy(...orderBy: Array<OrderBy>): SelectSingle<T>;
+        groupBy(...groupBy: Array<Expr<any>>): SelectSingle<T>;
+        where(...where: Array<EV<boolean>>): SelectSingle<T>;
+        toExpr(): Expr<T>;
+    }
+}

package/dist/Cursor.js

@@ -0,0 +1,211 @@
+// src/Cursor.ts
+import { Expr, ExprData } from "./Expr";
+import { Functions } from "./Functions";
+import { Query } from "./Query";
+import { Target } from "./Target";
+var Cursor = class {
+  constructor(query) {
+    Object.defineProperty(this, "query", {
+      enumerable: false,
+      value: () => query
+    });
+  }
+  query() {
+    throw new Error("Not implemented");
+  }
+  toJSON() {
+    return this.query();
+  }
+};
+((Cursor2) => {
+  class Limitable extends Cursor2 {
+    take(limit) {
+      return new Limitable({ ...this.query(), limit });
+    }
+    skip(offset) {
+      return new Limitable({ ...this.query(), offset });
+    }
+  }
+  Cursor2.Limitable = Limitable;
+  class Filterable extends Limitable {
+    where(...where) {
+      const condition = Expr.and(...where);
+      const query = this.query();
+      return new Filterable({
+        ...query,
+        where: (query.where ? condition.and(new Expr(query.where)) : condition).expr
+      });
+    }
+  }
+  Cursor2.Filterable = Filterable;
+  class Delete extends Filterable {
+    query() {
+      return super.query();
+    }
+  }
+  Cursor2.Delete = Delete;
+  class Update extends Filterable {
+    set(set) {
+      return new Update({ ...this.query(), set });
+    }
+  }
+  Cursor2.Update = Update;
+  class InsertValuesReturning extends Cursor2 {
+  }
+  Cursor2.InsertValuesReturning = InsertValuesReturning;
+  class InsertValues extends Cursor2 {
+    query() {
+      return super.query();
+    }
+    returning(selection) {
+      return new InsertValuesReturning(
+        Query.Insert({ ...this.query(), selection: ExprData.create(selection) })
+      );
+    }
+  }
+  Cursor2.InsertValues = InsertValues;
+  class Insert {
+    constructor(into) {
+      this.into = into;
+    }
+    values(...data) {
+      return new InsertValues(Query.Insert({ into: this.into, data }));
+    }
+  }
+  Cursor2.Insert = Insert;
+  class Create extends Cursor2 {
+    constructor(table) {
+      super(Query.CreateTable({ table, ifNotExists: true }));
+      this.table = table;
+    }
+  }
+  Cursor2.Create = Create;
+  class Batch extends Cursor2 {
+    constructor(queries) {
+      super(Query.Batch({ queries }));
+      this.queries = queries;
+    }
+  }
+  Cursor2.Batch = Batch;
+  class SelectMultiple extends Filterable {
+    query() {
+      return super.query();
+    }
+    leftJoin(that, ...on) {
+      const query = this.query();
+      return new SelectMultiple({
+        ...query,
+        from: Target.Join(
+          query.from,
+          Target.Table(that.data()),
+          "left",
+          Expr.and(...on).expr
+        )
+      });
+    }
+    innerJoin(that, ...on) {
+      const query = this.query();
+      return new SelectMultiple({
+        ...query,
+        from: Target.Join(
+          query.from,
+          Target.Table(that.data()),
+          "inner",
+          Expr.and(...on).expr
+        )
+      });
+    }
+    select(selection) {
+      return new SelectMultiple({
+        ...this.query(),
+        selection: ExprData.create(selection)
+      });
+    }
+    count() {
+      return new SelectSingle({
+        ...this.query(),
+        selection: Functions.count().expr,
+        singleResult: true
+      });
+    }
+    orderBy(...orderBy) {
+      return new SelectMultiple({
+        ...this.query(),
+        orderBy
+      });
+    }
+    groupBy(...groupBy) {
+      return new SelectMultiple({
+        ...this.query(),
+        groupBy: groupBy.map(ExprData.create)
+      });
+    }
+    first() {
+      return new SelectSingle({ ...this.query(), singleResult: true });
+    }
+    where(...where) {
+      return new SelectMultiple(super.where(...where).query());
+    }
+    toExpr() {
+      return new Expr(ExprData.Query(this.query()));
+    }
+  }
+  Cursor2.SelectMultiple = SelectMultiple;
+  class SelectSingle extends Filterable {
+    query() {
+      return super.query();
+    }
+    leftJoin(that, ...on) {
+      const query = this.query();
+      return new SelectSingle({
+        ...query,
+        from: Target.Join(
+          query.from,
+          Target.Table(that.data()),
+          "left",
+          Expr.and(...on).expr
+        )
+      });
+    }
+    innerJoin(that, ...on) {
+      const query = this.query();
+      return new SelectSingle({
+        ...query,
+        from: Target.Join(
+          query.from,
+          Target.Table(that.data()),
+          "inner",
+          Expr.and(...on).expr
+        )
+      });
+    }
+    select(selection) {
+      return new SelectSingle({
+        ...this.query(),
+        selection: ExprData.create(selection)
+      });
+    }
+    orderBy(...orderBy) {
+      return new SelectSingle({
+        ...this.query(),
+        orderBy
+      });
+    }
+    groupBy(...groupBy) {
+      return new SelectSingle({
+        ...this.query(),
+        groupBy: groupBy.map(ExprData.create)
+      });
+    }
+    where(...where) {
+      return new SelectSingle(super.where(...where).query());
+    }
+    toExpr() {
+      return new Expr(ExprData.Query(this.query()));
+    }
+  }
+  Cursor2.SelectSingle = SelectSingle;
+})(Cursor || (Cursor = {}));
+export {
+  Cursor
+};

package/dist/Driver.d.ts

@@ -0,0 +1,72 @@
+import { Cursor } from './Cursor';
+import { Formatter } from './Formatter';
+import { Query } from './Query';
+import { Schema } from './Schema';
+import { Statement } from './Statement';
+declare class Callable extends Function {
+    constructor(fn: Function);
+}
+declare abstract class DriverBase extends Callable {
+    formatter: Formatter;
+    constructor(formatter: Formatter);
+    all(strings: TemplateStringsArray, ...params: Array<any>): any;
+    get(strings: TemplateStringsArray, ...params: Array<any>): any;
+    executeTemplate(expectedReturn: Query.RawReturn, strings: TemplateStringsArray, ...params: Array<any>): any;
+    abstract executeQuery(query: Query<any>): any;
+}
+export declare namespace Driver {
+    export interface Sync {
+        <T>(query: Cursor<T>): T;
+        (strings: TemplateStringsArray, ...values: any[]): any;
+    }
+    export abstract class Sync extends DriverBase {
+        transactionId: number;
+        abstract rows(stmt: Statement.Compiled): Array<object>;
+        abstract values(stmt: Statement.Compiled): Array<Array<any>>;
+        abstract execute(stmt: Statement.Compiled): void;
+        abstract mutate(stmt: Statement.Compiled): {
+            rowsAffected: number;
+        };
+        abstract schema(tableName: string): Schema;
+        executeQuery<T>(query: Query<T>): T;
+        all<T>(strings: TemplateStringsArray, ...params: Array<any>): Array<T>;
+        get<T>(strings: TemplateStringsArray, ...params: Array<any>): T;
+        transaction<T>(run: (query: Sync) => T): T;
+        toAsync(): SyncWrapper;
+    }
+    export interface Async {
+        <T>(query: Cursor<T>): Promise<T>;
+        (strings: TemplateStringsArray, ...values: any[]): Promise<any>;
+    }
+    export abstract class Async extends DriverBase {
+        transactionId: number;
+        abstract isolate(): [connection: Async, release: () => Promise<void>];
+        abstract rows(stmt: Statement.Compiled): Promise<Array<object>>;
+        abstract values(stmt: Statement.Compiled): Promise<Array<Array<any>>>;
+        abstract execute(stmt: Statement.Compiled): Promise<void>;
+        abstract mutate(stmt: Statement.Compiled): Promise<{
+            rowsAffected: number;
+        }>;
+        abstract schema(tableName: string): Promise<Schema>;
+        executeQuery<T>(query: Query<T>): Promise<T>;
+        all<T>(strings: TemplateStringsArray, ...params: Array<any>): Promise<Array<T>>;
+        get<T>(strings: TemplateStringsArray, ...params: Array<any>): Promise<T>;
+        transaction<T>(run: (query: Async) => T): Promise<T>;
+    }
+    class SyncWrapper extends Async {
+        private sync;
+        lock: Promise<void> | undefined;
+        constructor(sync: Sync);
+        executeQuery<T>(query: Query<T>): Promise<T>;
+        rows(stmt: Statement.Compiled): Promise<Array<object>>;
+        values(stmt: Statement.Compiled): Promise<Array<Array<any>>>;
+        execute(stmt: Statement.Compiled): Promise<void>;
+        mutate(stmt: Statement.Compiled): Promise<{
+            rowsAffected: number;
+        }>;
+        schema(tableName: string): Promise<Schema>;
+        isolate(): [connection: Async, release: () => Promise<void>];
+    }
+    export {};
+}
+export {};

package/dist/Driver.js

@@ -0,0 +1,145 @@
+// src/Driver.ts
+import { Cursor } from "./Cursor";
+import { Query, QueryType } from "./Query";
+var Callable = class extends Function {
+  constructor(fn) {
+    super();
+    return new Proxy(this, {
+      apply(_, thisArg, input) {
+        return fn.apply(thisArg, input);
+      }
+    });
+  }
+};
+var DriverBase = class extends Callable {
+  constructor() {
+    super((...args) => {
+      const [input, ...rest] = args;
+      if (input instanceof Cursor)
+        return this.executeQuery(input.query());
+      return this.executeTemplate(void 0, input, ...rest);
+    });
+  }
+  all(strings, ...params) {
+    return this.executeTemplate("rows", strings, ...params);
+  }
+  get(strings, ...params) {
+    return this.executeTemplate("row", strings, ...params);
+  }
+  executeTemplate(expectedReturn, strings, ...params) {
+    if (strings.some((chunk) => chunk.includes("?")))
+      throw new TypeError("SQL injection hazard");
+    return this.executeQuery(Query.Raw({ strings, params, expectedReturn }));
+  }
+};
+var Driver;
+((Driver2) => {
+  class Sync extends DriverBase {
+    transactionId = 0;
+    executeQuery(query) {
+      switch (query.type) {
+        case QueryType.Batch:
+          let result;
+          const stmts = query.queries;
+          for (const query2 of stmts)
+            result = this.execute(query2);
+          return result;
+        default:
+          return this.execute(query);
+      }
+    }
+    all(strings, ...params) {
+      return super.all(strings, ...params);
+    }
+    get(strings, ...params) {
+      return super.get(strings, ...params);
+    }
+    transaction(run) {
+      const id = `t${this.transactionId++}`;
+      this.execute(
+        Query.Transaction({ op: Query.TransactionOperation.Begin, id })
+      );
+      try {
+        const res = run(this);
+        this.execute(
+          Query.Transaction({ op: Query.TransactionOperation.Commit, id })
+        );
+        return res;
+      } catch (e) {
+        this.execute(
+          Query.Transaction({ op: Query.TransactionOperation.Rollback, id })
+        );
+        throw e;
+      }
+    }
+    toAsync() {
+      return new SyncWrapper(this);
+    }
+  }
+  Driver2.Sync = Sync;
+  class Async extends DriverBase {
+    transactionId = 0;
+    async executeQuery(query) {
+      switch (query.type) {
+        case QueryType.Batch:
+          let result;
+          const stmts = query.queries;
+          for (const query2 of stmts)
+            result = await this.execute(query2);
+          return result;
+        default:
+          return this.execute(query);
+      }
+    }
+    all(strings, ...params) {
+      return super.all(strings, ...params);
+    }
+    get(strings, ...params) {
+      return super.get(strings, ...params);
+    }
+    async transaction(run) {
+      const id = `t${this.transactionId++}`;
+      const [connection, release] = this.isolate();
+      await connection.execute(
+        Query.Transaction({ op: Query.TransactionOperation.Begin, id })
+      );
+      try {
+        const res = await run(connection);
+        await connection.execute(
+          Query.Transaction({ op: Query.TransactionOperation.Commit, id })
+        );
+        return res;
+      } catch (e) {
+        await connection.execute(
+          Query.Transaction({ op: Query.TransactionOperation.Rollback, id })
+        );
+        throw e;
+      } finally {
+        await release();
+      }
+    }
+  }
+  Driver2.Async = Async;
+  class SyncWrapper extends Async {
+    constructor(sync) {
+      super();
+      this.sync = sync;
+    }
+    lock;
+    async execute(query) {
+      await this.lock;
+      return this.sync.execute(query);
+    }
+    isolate() {
+      const connection = new SyncWrapper(this.sync);
+      let release, trigger = new Promise((resolve) => {
+        release = async () => resolve();
+      });
+      this.lock = Promise.resolve(this.lock).then(() => trigger);
+      return [connection, release];
+    }
+  }
+})(Driver || (Driver = {}));
+export {
+  Driver
+};