rado 0.1.62 → 0.1.64

package/dist/src/driver/sql.js.js

@@ -1,66 +0,0 @@
-// src/driver/sql.js.ts
-import { Driver } from "../lib/Driver.js";
-import { SqliteFormatter } from "../sqlite/SqliteFormatter.js";
-import { SqliteSchema } from "../sqlite/SqliteSchema.js";
-var PreparedStatement = class {
-  constructor(db, stmt, discardAfter) {
-    this.db = db;
-    this.stmt = stmt;
-    this.discardAfter = discardAfter;
-  }
-  all(params) {
-    this.stmt.bind(params);
-    const res = [];
-    while (this.stmt.step())
-      res.push(this.stmt.getAsObject());
-    if (this.discardAfter)
-      this.stmt.free();
-    return res;
-  }
-  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) {
-    return new PreparedStatement(
-      this.db,
-      this.db.prepare(stmt.sql),
-      discardAfter
-    );
-  }
-  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/src/driver/sqlite3.js

@@ -1,87 +0,0 @@
-// src/driver/sqlite3.ts
-import { Driver } from "../lib/Driver.js";
-import { SqliteFormatter } from "../sqlite/SqliteFormatter.js";
-import { SqliteSchema } from "../sqlite/SqliteSchema.js";
-var PreparedStatement = class {
-  constructor(stmt) {
-    this.stmt = stmt;
-  }
-  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) {
-    return new PreparedStatement(this.db.prepare(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/src/index.js

@@ -1,24 +0,0 @@
-// src/index.ts
-export * from "./lib/Column.js";
-export * from "./lib/Cursor.js";
-export * from "./lib/Driver.js";
-export * from "./lib/Expr.js";
-export * from "./lib/Fields.js";
-export * from "./lib/Formatter.js";
-import { Functions } from "./lib/Functions.js";
-export * from "./lib/Id.js";
-export * from "./lib/Index.js";
-export * from "./lib/Ops.js";
-export * from "./lib/OrderBy.js";
-export * from "./lib/Param.js";
-export * from "./lib/Query.js";
-export * from "./lib/Sanitizer.js";
-export * from "./lib/Schema.js";
-export * from "./lib/Selection.js";
-export * from "./lib/Statement.js";
-export * from "./lib/Table.js";
-export * from "./lib/Target.js";
-export * from "./lib/Update.js";
-export {
-  Functions
-};

package/dist/src/lib/Column.js

@@ -1,63 +0,0 @@
-// src/lib/Column.ts
-import { ExprData } from "./Expr.js";
-var ColumnType = /* @__PURE__ */ ((ColumnType2) => {
-  ColumnType2["String"] = "String";
-  ColumnType2["Integer"] = "Integer";
-  ColumnType2["Number"] = "Number";
-  ColumnType2["Boolean"] = "Boolean";
-  ColumnType2["Json"] = "Json";
-  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 });
-  }
-  references(column2) {
-    return new Column({ ...this.data, references: ExprData.create(column2) });
-  }
-  unique() {
-    return new Column({ ...this.data, unique: true });
-  }
-  defaultValue(value) {
-    return new Column({ ...this.data, defaultValue: ExprData.create(value) });
-  }
-};
-((Column2) => {
-})(Column || (Column = {}));
-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: "Json" /* Json */ });
-  },
-  array() {
-    return new Column({ type: "Json" /* Json */ });
-  }
-};
-export {
-  Column,
-  ColumnType,
-  column
-};

package/dist/src/lib/Cursor.js

@@ -1,231 +0,0 @@
-// src/lib/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
-    });
-  }
-  static all(strings, ...params) {
-    return new Cursor(Query.Raw({ expectedReturn: "rows", strings, params }));
-  }
-  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 });
-    }
-    sure() {
-      return new SelectSingle({
-        ...this.query(),
-        singleResult: true,
-        validate: 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
-};