rado 0.3.2 → 0.3.4

package/dist/src/driver/sqlite3.js

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

@@ -0,0 +1,24 @@
+// 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/{lib → src/lib}/Column.js

@@ -25,12 +25,7 @@ var Column = class {
     return new Column({ ...this.data, primaryKey: true });
   }
   references(column2) {
-    return new Column({
-      ...this.data,
-      get references() {
-        return ExprData.create(typeof column2 === "function" ? column2() : column2);
-      }
-    });
+    return new Column({ ...this.data, references: ExprData.create(column2) });
   }
   unique() {
     return new Column({ ...this.data, unique: true });

package/dist/{lib → src/lib}/Cursor.js

@@ -21,54 +21,41 @@ var Cursor = class {
   query() {
     throw new Error("Not implemented");
   }
-  on(driver) {
-    return driver.executeQuery(this.query());
-  }
   toJSON() {
     return this.query();
   }
 };
-function addWhere(query, where) {
-  const conditions = where.slice();
-  if (query.where)
-    conditions.push(query.where);
-  return {
-    ...query,
-    where: Expr.and(...conditions).expr
-  };
-}
 ((Cursor2) => {
-  class Delete extends Cursor2 {
-    query() {
-      return super.query();
-    }
-    where(...where) {
-      return new Delete(addWhere(this.query(), where));
-    }
+  class Limitable extends Cursor2 {
     take(limit) {
-      return new Delete({ ...this.query(), limit });
+      return new Limitable({ ...this.query(), limit });
     }
     skip(offset) {
-      return new Delete({ ...this.query(), offset });
+      return new Limitable({ ...this.query(), offset });
     }
   }
-  Cursor2.Delete = Delete;
-  class Update extends Cursor2 {
+  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 });
     }
-    where(...where) {
-      return new Update(addWhere(this.query(), where));
-    }
-    take(limit) {
-      return new Update({ ...this.query(), limit });
-    }
-    skip(offset) {
-      return new Update({ ...this.query(), offset });
-    }
   }
   Cursor2.Update = Update;
   class InsertValuesReturning extends Cursor2 {
@@ -94,13 +81,13 @@ function addWhere(query, where) {
     }
   }
   Cursor2.Insert = Insert;
-  class CreateTable extends Cursor2 {
+  class Create extends Cursor2 {
     constructor(table) {
       super(Schema.create(table));
       this.table = table;
     }
   }
-  Cursor2.CreateTable = CreateTable;
+  Cursor2.Create = Create;
   class Batch extends Cursor2 {
     constructor(queries) {
       super(Query.Batch({ queries }));
@@ -108,7 +95,7 @@ function addWhere(query, where) {
     }
   }
   Cursor2.Batch = Batch;
-  class SelectMultiple extends Cursor2 {
+  class SelectMultiple extends Filterable {
     query() {
       return super.query();
     }
@@ -174,20 +161,14 @@ function addWhere(query, where) {
       });
     }
     where(...where) {
-      return new SelectMultiple(addWhere(this.query(), where));
-    }
-    take(limit) {
-      return new SelectMultiple({ ...this.query(), limit });
-    }
-    skip(offset) {
-      return new SelectMultiple({ ...this.query(), offset });
+      return new SelectMultiple(super.where(...where).query());
     }
     toExpr() {
       return new Expr(ExprData.Query(this.query()));
     }
   }
   Cursor2.SelectMultiple = SelectMultiple;
-  class SelectSingle extends Cursor2 {
+  class SelectSingle extends Filterable {
     query() {
       return super.query();
     }
@@ -234,13 +215,7 @@ function addWhere(query, where) {
       });
     }
     where(...where) {
-      return new SelectSingle(addWhere(this.query(), where));
-    }
-    take(limit) {
-      return new SelectSingle({ ...this.query(), limit });
-    }
-    skip(offset) {
-      return new SelectSingle({ ...this.query(), offset });
+      return new SelectSingle(super.where(...where).query());
     }
     all() {
       return new SelectMultiple({ ...this.query(), singleResult: false });

package/dist/src/lib/Driver.js

@@ -0,0 +1,316 @@
+// src/lib/Driver.ts
+import { Cursor } from "./Cursor.js";
+import { Expr, ExprData } from "./Expr.js";
+import { ParamData } from "./Param.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;
+  }
+  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.query();
+    return [query, this.formatter.compile(query)];
+  }
+  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;
+  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 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, 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)
+              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);
+  }
+  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 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, 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)
+              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 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 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
+};

package/dist/{lib → src/lib}/Expr.js

@@ -187,10 +187,10 @@ var _Expr = class {
       return this.isNull();
     return binop(this, "Equals" /* Equals */, that);
   }
-  in(that) {
+  isIn(that) {
     return binop(this, "In" /* In */, that);
   }
-  notIn(that) {
+  isNotIn(that) {
     return binop(this, "NotIn" /* NotIn */, that);
   }
   add(that) {
@@ -242,7 +242,7 @@ var _Expr = class {
   }
   filter(fn) {
     const alias = `__${Math.random().toString(36).slice(2, 9)}`;
-    const target = Target.Expr(this.expr, alias);
+    const target = Target.Each(this.expr, alias);
     return new _Expr(
       ExprData.Filter(
         target,
@@ -252,7 +252,7 @@ var _Expr = class {
   }
   map(fn) {
     const alias = `__${Math.random().toString(36).slice(2, 9)}`;
-    const target = Target.Expr(this.expr, alias);
+    const target = Target.Each(this.expr, alias);
     return new _Expr(
       ExprData.Map(
         target,