rado 0.1.60 → 0.1.62

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> {
+    [Selection.__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<Expr<any> | 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>;
+        all(): SelectMultiple<T>;
+        toExpr(): Expr<T>;
+    }
+}

package/dist/Cursor.js

@@ -0,0 +1,221 @@
+// src/Cursor.ts
+import { Expr, ExprData } from "./Expr.js";
+import { Functions } from "./Functions.js";
+import { Query } from "./Query.js";
+import { Schema } from "./Schema.js";
+import { Selection } from "./Selection.js";
+import { Target } from "./Target.js";
+var Cursor = class {
+  [Selection.__cursorType]() {
+    throw "assert";
+  }
+  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(Schema.create(table));
+      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.schema()),
+          "left",
+          Expr.and(...on).expr
+        )
+      });
+    }
+    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
+        )
+      });
+    }
+    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: orderBy.map((e) => {
+          return e instanceof Expr ? e.asc() : e;
+        })
+      });
+    }
+    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.schema()),
+          "left",
+          Expr.and(...on).expr
+        )
+      });
+    }
+    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
+        )
+      });
+    }
+    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());
+    }
+    all() {
+      return new SelectMultiple({ ...this.query(), singleResult: false });
+    }
+    toExpr() {
+      return new Expr(ExprData.Query(this.query()));
+    }
+  }
+  Cursor2.SelectSingle = SelectSingle;
+})(Cursor || (Cursor = {}));
+export {
+  Cursor
+};

package/dist/Driver.d.ts

@@ -0,0 +1,89 @@
+import { Cursor } from './Cursor';
+import { Formatter } from './Formatter';
+import { Query } from './Query';
+import { SchemaInstructions } from './Schema';
+import { Statement } from './Statement';
+import { Table } from './Table';
+declare class Callable extends Function {
+    constructor(fn: Function);
+}
+declare abstract class DriverBase extends Callable {
+    formatter: Formatter;
+    constructor(formatter: Formatter);
+    all(...args: Array<any>): any;
+    get(...args: Array<any>): any;
+    sql(strings: TemplateStringsArray, ...params: Array<any>): Cursor<unknown>;
+    executeTemplate(expectedReturn: Query.RawReturn, strings: TemplateStringsArray, ...params: Array<any>): any;
+    abstract executeQuery(query: Query<any>): any;
+}
+interface SyncDriver {
+    <T>(query: Cursor<T>): T;
+    <T>(...queries: Array<Cursor<any>>): T;
+    (strings: TemplateStringsArray, ...values: any[]): any;
+}
+declare abstract class SyncDriver 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 schemaInstructions(tableName: string): SchemaInstructions | undefined;
+    migrateSchema(...tables: Array<Table<any>>): unknown;
+    executeQuery<T>(query: Query<T>): T;
+    all<T>(cursor: Cursor.SelectSingle<T>): Array<T>;
+    all<T>(cursor: Cursor<T>): Array<T>;
+    all<T>(strings: TemplateStringsArray, ...params: Array<any>): Array<T>;
+    get<T>(cursor: Cursor.SelectMultiple<T>): T | null;
+    get<T>(cursor: Cursor<T>): T;
+    get<T>(strings: TemplateStringsArray, ...params: Array<any>): T;
+    transaction<T>(run: (query: SyncDriver) => T): T;
+    toAsync(): SyncWrapper;
+}
+interface AsyncDriver {
+    <T>(query: Cursor<T>): Promise<T>;
+    <T>(...queries: Array<Cursor<any>>): Promise<T>;
+    (strings: TemplateStringsArray, ...values: any[]): Promise<any>;
+}
+declare abstract class AsyncDriver extends DriverBase {
+    transactionId: number;
+    abstract isolate(): [connection: AsyncDriver, 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 schemaInstructions(tableName: string): Promise<SchemaInstructions | undefined>;
+    migrateSchema(...tables: Array<Table<any>>): Promise<unknown>;
+    executeQuery<T>(query: Query<T>): Promise<T>;
+    all<T>(cursor: Cursor.SelectSingle<T>): Promise<Array<T>>;
+    all<T>(cursor: Cursor<T>): Promise<T>;
+    all<T>(strings: TemplateStringsArray, ...params: Array<any>): Promise<Array<T>>;
+    get<T>(cursor: Cursor.SelectMultiple<T>): Promise<T | null>;
+    get<T>(cursor: Cursor<T>): Promise<T>;
+    get<T>(strings: TemplateStringsArray, ...params: Array<any>): Promise<T>;
+    transaction<T>(run: (query: AsyncDriver) => T): Promise<T>;
+}
+declare class SyncWrapper extends AsyncDriver {
+    private sync;
+    lock: Promise<void> | undefined;
+    constructor(sync: SyncDriver);
+    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;
+    }>;
+    schemaInstructions(tableName: string): Promise<SchemaInstructions | undefined>;
+    isolate(): [connection: AsyncDriver, release: () => Promise<void>];
+}
+export declare namespace Driver {
+    type Sync = SyncDriver;
+    const Sync: typeof SyncDriver;
+    type Async = AsyncDriver;
+    const Async: typeof AsyncDriver;
+}
+export {};

package/dist/Driver.js

@@ -0,0 +1,262 @@
+// src/Driver.ts
+import { Cursor } from "./Cursor.js";
+import { Query, QueryType } from "./Query.js";
+import { Schema } from "./Schema.js";
+var Callable = class extends Function {
+  constructor(fn) {
+    super();
+    return new Proxy(this, {
+      apply(_, thisArg, input) {
+        return fn.apply(thisArg, input);
+      }
+    });
+  }
+};
+function isTemplateStringsArray(input) {
+  return Boolean(Array.isArray(input) && input.raw);
+}
+var DriverBase = class extends Callable {
+  constructor(formatter) {
+    super((...args) => {
+      const [input, ...rest] = args;
+      if (input instanceof Cursor && rest.length === 0)
+        return this.executeQuery(input.query());
+      if (isTemplateStringsArray(input))
+        return this.executeTemplate(void 0, input, ...rest);
+      return this.executeQuery(
+        Query.Batch({
+          queries: args.filter((arg) => arg instanceof Cursor).map((arg) => arg.query())
+        })
+      );
+    });
+    this.formatter = formatter;
+  }
+  all(...args) {
+    const [input, ...rest] = args;
+    if (input instanceof Cursor.SelectSingle)
+      return this.executeQuery(input.all().query());
+    if (input instanceof Cursor)
+      return this.executeQuery(input.query());
+    return this.executeTemplate("rows", input, ...rest);
+  }
+  get(...args) {
+    const [input, ...rest] = args;
+    if (input instanceof Cursor.SelectMultiple)
+      return this.executeQuery(input.first().query());
+    if (input instanceof Cursor)
+      return this.executeQuery(input.query());
+    return this.executeTemplate("row", input, ...rest);
+  }
+  sql(strings, ...params) {
+    return new Cursor(Query.Raw({ strings, params }));
+  }
+  executeTemplate(expectedReturn, strings, ...params) {
+    return this.executeQuery(Query.Raw({ strings, params, expectedReturn }));
+  }
+};
+var SyncDriver = class extends DriverBase {
+  transactionId = 0;
+  migrateSchema(...tables) {
+    const queries = [];
+    for (const table of Object.values(tables)) {
+      const schema = table.schema();
+      const localSchema = this.schemaInstructions(schema.name);
+      if (!localSchema) {
+        queries.push(...Schema.create(schema).queries);
+      } else {
+        const changes = Schema.upgrade(this.formatter, localSchema, schema);
+        if (changes.length)
+          queries.push(...changes);
+      }
+    }
+    return this.executeQuery(Query.Batch({ queries }));
+  }
+  executeQuery(query) {
+    switch (query.type) {
+      case QueryType.Batch:
+        let result;
+        const stmts = query.queries;
+        if (stmts.length === 0)
+          return void 0;
+        if (stmts.length === 1)
+          return this.executeQuery(stmts[0]);
+        return this.transaction((cnx) => {
+          for (const query2 of stmts)
+            result = cnx.executeQuery(query2);
+          return result;
+        });
+      default:
+        const stmt = this.formatter.compile(query);
+        if ("selection" in query) {
+          const res = this.values(stmt).map(([item]) => JSON.parse(item).result);
+          if (query.singleResult)
+            return res[0];
+          return res;
+        } else if (query.type === QueryType.Raw) {
+          switch (query.expectedReturn) {
+            case "row":
+              return this.rows(stmt)[0];
+            case "rows":
+              return this.rows(stmt);
+            default:
+              this.execute(stmt);
+              return void 0;
+          }
+        } else {
+          return this.mutate(stmt);
+        }
+    }
+  }
+  all(...args) {
+    return super.all(...args);
+  }
+  get(...args) {
+    return super.get(...args);
+  }
+  transaction(run) {
+    const id = `t${this.transactionId++}`;
+    this.executeQuery(
+      Query.Transaction({ op: Query.TransactionOperation.Begin, id })
+    );
+    try {
+      const res = run(this);
+      this.executeQuery(
+        Query.Transaction({ op: Query.TransactionOperation.Commit, id })
+      );
+      return res;
+    } catch (e) {
+      this.executeQuery(
+        Query.Transaction({ op: Query.TransactionOperation.Rollback, id })
+      );
+      throw e;
+    }
+  }
+  toAsync() {
+    return new SyncWrapper(this);
+  }
+};
+var AsyncDriver = class extends DriverBase {
+  transactionId = 0;
+  async migrateSchema(...tables) {
+    const queries = [];
+    for (const table of Object.values(tables)) {
+      const schema = table.schema();
+      const localSchema = await this.schemaInstructions(schema.name);
+      if (!localSchema) {
+        queries.push(...Schema.create(schema).queries);
+      } else {
+        const changes = Schema.upgrade(this.formatter, localSchema, schema);
+        if (changes.length)
+          queries.push(...changes);
+      }
+    }
+    return this.executeQuery(Query.Batch({ queries }));
+  }
+  async executeQuery(query) {
+    switch (query.type) {
+      case QueryType.Batch:
+        let result;
+        const stmts = query.queries;
+        if (stmts.length === 0)
+          return void 0;
+        if (stmts.length === 1)
+          return this.executeQuery(stmts[0]);
+        return this.transaction(async (cnx) => {
+          for (const query2 of stmts)
+            result = await cnx.executeQuery(query2);
+          return result;
+        });
+      default:
+        const stmt = this.formatter.compile(query);
+        if ("selection" in query) {
+          const res = (await this.values(stmt)).map(
+            ([item]) => JSON.parse(item).result
+          );
+          if (query.singleResult)
+            return res[0];
+          return res;
+        } else if (query.type === QueryType.Raw) {
+          switch (query.expectedReturn) {
+            case "row":
+              return (await this.rows(stmt))[0];
+            case "rows":
+              return await this.rows(stmt);
+            default:
+              await this.execute(stmt);
+              return void 0;
+          }
+        } else {
+          return await this.mutate(stmt);
+        }
+    }
+  }
+  all(...args) {
+    return super.all(...args);
+  }
+  get(...args) {
+    return super.get(...args);
+  }
+  async transaction(run) {
+    const id = `t${this.transactionId++}`;
+    const [connection, release] = this.isolate();
+    await connection.executeQuery(
+      Query.Transaction({ op: Query.TransactionOperation.Begin, id })
+    );
+    try {
+      const res = await run(connection);
+      await connection.executeQuery(
+        Query.Transaction({ op: Query.TransactionOperation.Commit, id })
+      );
+      return res;
+    } catch (e) {
+      await connection.executeQuery(
+        Query.Transaction({ op: Query.TransactionOperation.Rollback, id })
+      );
+      throw e;
+    } finally {
+      await release();
+    }
+  }
+};
+var SyncWrapper = class extends AsyncDriver {
+  constructor(sync) {
+    super(sync.formatter);
+    this.sync = sync;
+  }
+  lock;
+  async executeQuery(query) {
+    await this.lock;
+    return super.executeQuery(query);
+  }
+  async rows(stmt) {
+    return this.sync.rows(stmt);
+  }
+  async values(stmt) {
+    return this.sync.values(stmt);
+  }
+  async execute(stmt) {
+    return this.sync.execute(stmt);
+  }
+  async mutate(stmt) {
+    return this.sync.mutate(stmt);
+  }
+  async schemaInstructions(tableName) {
+    return this.sync.schemaInstructions(tableName);
+  }
+  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];
+  }
+};
+var Driver;
+((Driver2) => {
+  Driver2.Sync = SyncDriver;
+  Driver2.Async = AsyncDriver;
+})(Driver || (Driver = {}));
+export {
+  Driver
+};