rado 0.4.6 → 0.4.8

package/dist/deno/driver/sql.js.js

@@ -1,72 +0,0 @@
-// src/driver/sql.js.ts
-import { Driver } from "../lib/Driver.ts";
-import { SqlError } from "../lib/SqlError.ts";
-import { SqliteFormatter } from "../sqlite/SqliteFormatter.ts";
-import { SqliteSchema } from "../sqlite/SqliteSchema.ts";
-var PreparedStatement = class {
-  constructor(db, stmt, discardAfter) {
-    this.db = db;
-    this.stmt = stmt;
-    this.discardAfter = discardAfter;
-  }
-  *iterate(params) {
-    this.stmt.bind(params);
-    while (this.stmt.step())
-      yield this.stmt.getAsObject();
-    if (this.discardAfter)
-      this.stmt.free();
-  }
-  all(params) {
-    return Array.from(this.iterate(params));
-  }
-  run(params) {
-    this.stmt.run(params);
-    if (this.discardAfter)
-      this.stmt.free();
-    return { rowsAffected: this.db.getRowsModified() };
-  }
-  get(params) {
-    return this.all(params)[0];
-  }
-  execute(params) {
-    this.stmt.run(params);
-    if (this.discardAfter)
-      this.stmt.free();
-  }
-};
-var SqlJsDriver = class extends Driver.Sync {
-  constructor(db) {
-    super(new SqliteFormatter());
-    this.db = db;
-    this.tableData = this.prepare(SqliteSchema.tableData);
-    this.indexData = this.prepare(SqliteSchema.indexData);
-  }
-  tableData;
-  indexData;
-  prepareStatement(stmt, discardAfter) {
-    try {
-      return new PreparedStatement(
-        this.db,
-        this.db.prepare(stmt.sql),
-        discardAfter
-      );
-    } catch (e) {
-      throw new SqlError(e, stmt.sql);
-    }
-  }
-  schemaInstructions(tableName) {
-    const columnData = this.tableData(tableName);
-    const indexData = this.indexData(tableName);
-    return SqliteSchema.createInstructions(columnData, indexData);
-  }
-  export() {
-    return this.db.export();
-  }
-};
-function connect(db) {
-  return new SqlJsDriver(db);
-}
-export {
-  SqlJsDriver,
-  connect
-};

package/dist/deno/driver/sqlite3.js

@@ -1,123 +0,0 @@
-// src/driver/sqlite3.ts
-import { Driver } from "../lib/Driver.ts";
-import { SqlError } from "../lib/SqlError.ts";
-import { SqliteFormatter } from "../sqlite/SqliteFormatter.ts";
-import { SqliteSchema } from "../sqlite/SqliteSchema.ts";
-var PreparedStatement = class {
-  constructor(stmt) {
-    this.stmt = stmt;
-  }
-  async *iterate(params) {
-    let rows = [], done = false, error;
-    let resolve;
-    let promise = new Promise((r) => resolve = r);
-    this.stmt.each(
-      params,
-      (err, row) => {
-        if (err)
-          error = err;
-        else
-          rows.push(row);
-        resolve();
-      },
-      () => {
-        done = true;
-        resolve();
-      }
-    );
-    while (true) {
-      const mustWait = !(rows.length || error || done);
-      if (mustWait)
-        await promise;
-      promise = new Promise((r) => resolve = r);
-      if (error)
-        throw error;
-      if (rows.length)
-        yield rows.shift();
-      if (done)
-        return;
-    }
-  }
-  all(params) {
-    return new Promise((resolve, reject) => {
-      this.stmt.all(params, (err, rows) => {
-        if (err)
-          reject(err);
-        else
-          resolve(rows);
-      });
-    });
-  }
-  run(params) {
-    return new Promise((resolve, reject) => {
-      this.stmt.run(params, function(err) {
-        if (err)
-          reject(err);
-        else
-          resolve({ rowsAffected: this.changes });
-      });
-    });
-  }
-  get(params) {
-    return new Promise((resolve, reject) => {
-      this.stmt.get(params, (err, row) => {
-        if (err)
-          reject(err);
-        else
-          resolve(row);
-      });
-    });
-  }
-  execute(params) {
-    return new Promise((resolve, reject) => {
-      this.stmt.run(params, (err) => {
-        if (err)
-          reject(err);
-        else
-          resolve();
-      });
-    });
-  }
-};
-var Sqlite3Driver = class extends Driver.Async {
-  constructor(db) {
-    super(new SqliteFormatter());
-    this.db = db;
-    this.tableData = this.prepare(SqliteSchema.tableData);
-    this.indexData = this.prepare(SqliteSchema.indexData);
-  }
-  lock;
-  tableData;
-  indexData;
-  async executeQuery(query, stmt, params) {
-    await this.lock;
-    return super.executeQuery(query, stmt, params);
-  }
-  prepareStatement(stmt) {
-    try {
-      return new PreparedStatement(this.db.prepare(stmt.sql));
-    } catch (e) {
-      throw new SqlError(e, stmt.sql);
-    }
-  }
-  async schemaInstructions(tableName) {
-    const columnData = await this.tableData(tableName);
-    const indexData = await this.indexData(tableName);
-    return SqliteSchema.createInstructions(columnData, indexData);
-  }
-  isolate() {
-    const connection = new Sqlite3Driver(this.db);
-    let release, trigger = new Promise((resolve) => {
-      release = async () => resolve();
-    });
-    this.lock = Promise.resolve(this.lock).then(() => trigger);
-    return [connection, release];
-  }
-};
-function connect(db) {
-  return new Sqlite3Driver(db);
-}
-export {
-  Sqlite3Driver,
-  connect
-};

package/dist/deno/index.js

@@ -1,14 +0,0 @@
-// src/index.ts
-export * from "./define/Column.ts";
-export * from "./define/Cursor.ts";
-export * from "./define/Expr.ts";
-export * from "./define/Functions.ts";
-export * from "./define/Index.ts";
-export * from "./define/Ops.ts";
-export * from "./define/OrderBy.ts";
-export * from "./define/Param.ts";
-export * from "./define/Query.ts";
-export * from "./define/Schema.ts";
-export * from "./define/Table.ts";
-export * from "./define/Target.ts";
-export * from "./lib/SqlError.ts";

package/dist/deno/lib/Driver.js

@@ -1,330 +0,0 @@
-// src/lib/Driver.ts
-import { Cursor } from "../define/Cursor.ts";
-import { Expr, ExprData } from "../define/Expr.ts";
-import { ParamData } from "../define/Param.ts";
-import { Query, QueryType } from "../define/Query.ts";
-import { Schema } from "../define/Schema.ts";
-import { Table } from "../define/Table.ts";
-import { callable } from "../util/Callable.ts";
-function isTemplateStringsArray(input) {
-  return Boolean(Array.isArray(input) && input.raw);
-}
-var DriverBase = class {
-  constructor(formatter) {
-    this.formatter = formatter;
-    return callable(this, (...args) => {
-      const [input, ...rest] = args;
-      if (input instanceof Cursor && rest.length === 0)
-        return this.executeQuery(input[Cursor.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[Cursor.Query])
-        })
-      );
-    });
-  }
-  compile(create) {
-    const { length } = create;
-    const paramNames = Array.from({ length }, (_, i) => `p${i}`);
-    const params = paramNames.map(
-      (name) => new Expr(ExprData.Param(ParamData.Named(name)))
-    );
-    const cursor = create(...params);
-    const query = cursor[Cursor.Query];
-    return [query, this.formatter.compile(query)];
-  }
-  all(...args) {
-    const [input, ...rest] = args;
-    if (input instanceof Cursor.SelectSingle)
-      return this.executeQuery(input.all()[Cursor.Query]);
-    if (input instanceof Cursor)
-      return this.executeQuery(input[Cursor.Query]);
-    return this.executeTemplate("rows", input, ...rest);
-  }
-  get(...args) {
-    const [input, ...rest] = args;
-    if (input instanceof Cursor.SelectMultiple)
-      return this.executeQuery(input.first()[Cursor.Query]);
-    if (input instanceof Cursor)
-      return this.executeQuery(input[Cursor.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;
-  prepare(create) {
-    const [query, compiled] = this.compile(create);
-    const prepared = this.prepareStatement(compiled, false);
-    return (...params) => {
-      const namedParams = Object.fromEntries(
-        params.map((value, i) => [`p${i}`, value])
-      );
-      return this.executeQuery(query, prepared, compiled.params(namedParams));
-    };
-  }
-  migrateSchema(...tables) {
-    const queries = [];
-    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);
-      } else {
-        const changes = Schema.upgrade(this.formatter, localSchema, schema);
-        if (changes.length)
-          queries.push(...changes);
-      }
-    }
-    return this.executeQuery(Query.Batch({ queries }));
-  }
-  executeQuery(query, stmt, params) {
-    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 compiled = stmt ? void 0 : this.formatter.compile(query);
-        stmt = stmt || this.prepareStatement(compiled, true);
-        params = params || compiled.params();
-        if ("selection" in query) {
-          const res = stmt.all(params).map((row) => JSON.parse(row.result).result);
-          if (query.singleResult) {
-            const row = res[0];
-            if (query.validate && row === void 0)
-              throw new Error("No row found");
-            return row;
-          }
-          return res;
-        } else if (query.type === QueryType.Raw) {
-          switch (query.expectedReturn) {
-            case "row":
-              return stmt.all(params)[0];
-            case "rows":
-              return stmt.all(params);
-            default:
-              stmt.execute(params);
-              return void 0;
-          }
-        } else {
-          return stmt.run(params);
-        }
-    }
-  }
-  all(...args) {
-    return super.all(...args);
-  }
-  get(...args) {
-    return super.get(...args);
-  }
-  *iterate(cursor) {
-    const stmt = this.prepareStatement(
-      this.formatter.compile(cursor[Cursor.Query]),
-      true
-    );
-    for (const row of stmt.iterate()) {
-      yield JSON.parse(row.result).result;
-    }
-  }
-  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;
-  prepare(create) {
-    const [query, compiled] = this.compile(create);
-    const prepared = this.prepareStatement(compiled, false);
-    return (...params) => {
-      const namedParams = Object.fromEntries(
-        params.map((value, i) => [`p${i}`, value])
-      );
-      return this.executeQuery(query, prepared, compiled.params(namedParams));
-    };
-  }
-  async migrateSchema(...tables) {
-    const queries = [];
-    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);
-      } else {
-        const changes = Schema.upgrade(this.formatter, localSchema, schema);
-        if (changes.length)
-          queries.push(...changes);
-      }
-    }
-    return this.executeQuery(Query.Batch({ queries }));
-  }
-  async executeQuery(query, stmt, params) {
-    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 compiled = stmt ? void 0 : this.formatter.compile(query);
-        stmt = stmt || this.prepareStatement(compiled, true);
-        params = params || compiled.params();
-        if ("selection" in query) {
-          const res = (await stmt.all(params)).map(
-            (item) => JSON.parse(item.result).result
-          );
-          if (query.singleResult) {
-            const row = res[0];
-            if (query.validate && row === void 0)
-              throw new Error("No row found");
-            return row;
-          }
-          return res;
-        } else if (query.type === QueryType.Raw) {
-          switch (query.expectedReturn) {
-            case "row":
-              return (await stmt.all(params))[0];
-            case "rows":
-              return await stmt.all(params);
-            default:
-              await stmt.execute(params);
-              return void 0;
-          }
-        } else {
-          return await stmt.run(params);
-        }
-    }
-  }
-  all(...args) {
-    return super.all(...args);
-  }
-  get(...args) {
-    return super.get(...args);
-  }
-  async *iterate(cursor) {
-    const stmt = this.prepareStatement(
-      this.formatter.compile(cursor[Cursor.Query]),
-      true
-    );
-    for await (const row of stmt.iterate()) {
-      yield JSON.parse(row.result).result;
-    }
-  }
-  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 SyncPreparedStatementWrapper = class {
-  constructor(stmt) {
-    this.stmt = stmt;
-  }
-  async *iterate(params) {
-    for (const row of this.stmt.iterate(params))
-      yield row;
-  }
-  async run(params) {
-    return this.stmt.run(params);
-  }
-  async all(params) {
-    return this.stmt.all(params);
-  }
-  async get(params) {
-    return this.stmt.get(params);
-  }
-  async execute(params) {
-    return this.stmt.execute(params);
-  }
-};
-var SyncWrapper = class extends AsyncDriver {
-  constructor(sync) {
-    super(sync.formatter);
-    this.sync = sync;
-  }
-  lock;
-  async executeQuery(query, stmt, params) {
-    await this.lock;
-    return super.executeQuery(query, stmt, params);
-  }
-  prepareStatement(stmt, discardAfter) {
-    return new SyncPreparedStatementWrapper(
-      this.sync.prepareStatement(stmt, discardAfter)
-    );
-  }
-  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
-};