rado 0.1.62 → 0.1.63

package/dist/Cursor.d.ts

@@ -1,77 +0,0 @@
-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

@@ -1,221 +0,0 @@
-// 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

@@ -1,89 +0,0 @@
-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

@@ -1,262 +0,0 @@
-// 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
-};