rado 0.0.0 → 0.1.1

package/dist/driver/better-sqlite3.js

@@ -1,35 +1,33 @@
 // src/driver/better-sqlite3.ts
 import { Driver } from "../Driver.js";
-import { QueryType } from "../Query.js";
 import { SqliteFormatter } from "../sqlite/SqliteFormatter.js";
+import { SqliteSchema } from "../sqlite/SqliteSchema.js";
 var BetterSqlite3Driver = class extends Driver.Sync {
   constructor(db) {
-    super();
+    super(new SqliteFormatter());
     this.db = db;
   }
-  formatter = new SqliteFormatter();
-  execute(query) {
-    const [sql, params] = this.formatter.compile(query);
-    const stmt = this.db.prepare(sql);
-    if ("selection" in query) {
-      const res = stmt.pluck().all(...params).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 stmt.get(...params);
-        case "rows":
-          return stmt.all(...params);
-        default:
-          stmt.run(...params);
-          return void 0;
-      }
-    } else {
-      const { changes } = stmt.run(...params);
-      return { rowsAffected: changes };
-    }
+  rows([sql, params]) {
+    return this.db.prepare(sql).all(...params);
+  }
+  values([sql, params]) {
+    return this.db.prepare(sql).raw().all(...params);
+  }
+  execute([sql, params]) {
+    this.db.prepare(sql).run(...params);
+  }
+  mutate([sql, params]) {
+    const { changes } = this.db.prepare(sql).run(...params);
+    return { rowsAffected: changes };
+  }
+  schemaInstructions(tableName) {
+    const columnData = this.rows(
+      SqliteSchema.tableData(tableName).compile(this.formatter)
+    );
+    const indexData = this.rows(
+      SqliteSchema.indexData(tableName).compile(this.formatter)
+    );
+    return SqliteSchema.createInstructions(columnData, indexData);
   }
   export() {
     return this.db.serialize();

package/dist/driver/sql.js.d.ts

@@ -1,12 +1,17 @@
 import type { Database } from 'sql.js';
 import { Driver } from '../Driver';
-import { Query } from '../Query';
-import { SqliteFormatter } from '../sqlite/SqliteFormatter';
+import { SchemaInstructions } from '../Schema';
+import { Statement } from '../Statement';
 export declare class SqlJsDriver extends Driver.Sync {
-    private db;
-    formatter: SqliteFormatter;
+    db: Database;
     constructor(db: Database);
-    execute(query: Query): any;
+    rows<T extends object = object>([sql, params]: Statement.Compiled): Array<T>;
+    values([sql, params]: Statement.Compiled): Array<Array<any>>;
+    execute([sql, params]: Statement.Compiled): void;
+    mutate([sql, params]: Statement.Compiled): {
+        rowsAffected: number;
+    };
+    schemaInstructions(tableName: string): SchemaInstructions | undefined;
     export(): Uint8Array;
 }
 export declare function connect(db: Database): SqlJsDriver;

package/dist/driver/sql.js.js

@@ -1,44 +1,43 @@
 // src/driver/sql.js.ts
 import { Driver } from "../Driver.js";
-import { QueryType } from "../Query.js";
 import { SqliteFormatter } from "../sqlite/SqliteFormatter.js";
+import { SqliteSchema } from "../sqlite/SqliteSchema.js";
 var SqlJsDriver = class extends Driver.Sync {
   constructor(db) {
-    super();
+    super(new SqliteFormatter());
     this.db = db;
   }
-  formatter = new SqliteFormatter();
-  execute(query) {
-    const [sql, params] = this.formatter.compile(query);
+  rows([sql, params]) {
     const stmt = this.db.prepare(sql);
-    if ("selection" in query) {
-      stmt.bind(params);
-      const res = [];
-      while (stmt.step()) {
-        const row = stmt.get()[0];
-        res.push(JSON.parse(row).result);
-      }
-      if (query.singleResult)
-        return res[0];
-      return res;
-    } else if (query.type === QueryType.Raw) {
-      switch (query.expectedReturn) {
-        case "row":
-          return stmt.getAsObject(params);
-        case "rows":
-          stmt.bind(params);
-          const res = [];
-          while (stmt.step())
-            res.push(stmt.getAsObject());
-          return res;
-        default:
-          stmt.run(params);
-          return void 0;
-      }
-    } else {
-      stmt.run(params);
-      return { rowsAffected: this.db.getRowsModified() };
-    }
+    stmt.bind(params);
+    const res = [];
+    while (stmt.step())
+      res.push(stmt.getAsObject());
+    return res;
+  }
+  values([sql, params]) {
+    const stmt = this.db.prepare(sql);
+    stmt.bind(params);
+    const res = [];
+    while (stmt.step())
+      res.push(stmt.get());
+    return res;
+  }
+  execute([sql, params]) {
+    this.db.prepare(sql).run(params);
+  }
+  mutate([sql, params]) {
+    this.db.prepare(sql).run(params);
+    return { rowsAffected: this.db.getRowsModified() };
+  }
+  schemaInstructions(tableName) {
+    const columnData = this.rows(
+      SqliteSchema.tableData(tableName).compile(this.formatter)
+    );
+    const indexData = this.rows(
+      SqliteSchema.indexData(tableName).compile(this.formatter)
+    );
+    return SqliteSchema.createInstructions(columnData, indexData);
   }
   export() {
     return this.db.export();

package/dist/driver/sqlite3.d.ts

@@ -1,13 +1,20 @@
 import type { Database } from 'sqlite3';
 import { Driver } from '../Driver';
 import { Query } from '../Query';
-import { SqliteFormatter } from '../sqlite/SqliteFormatter';
+import { SchemaInstructions } from '../Schema';
+import { Statement } from '../Statement';
 export declare class Sqlite3Driver extends Driver.Async {
     private db;
-    formatter: SqliteFormatter;
     lock: Promise<void> | undefined;
     constructor(db: Database);
-    execute(query: Query): Promise<unknown>;
+    executeQuery<T>(query: Query<T>): Promise<T>;
+    rows<T extends object = object>([sql, params]: Statement.Compiled): Promise<Array<T>>;
+    values(stmt: Statement.Compiled): Promise<Array<Array<any>>>;
+    execute([sql, params]: Statement.Compiled): Promise<void>;
+    mutate([sql, params]: Statement.Compiled): Promise<{
+        rowsAffected: number;
+    }>;
+    schemaInstructions(tableName: string): Promise<SchemaInstructions | undefined>;
     isolate(): [connection: Driver.Async, release: () => Promise<void>];
 }
 export declare function connect(db: Database): Sqlite3Driver;

package/dist/driver/sqlite3.js

@@ -1,62 +1,63 @@
 // src/driver/sqlite3.ts
 import { Driver } from "../Driver.js";
-import { QueryType } from "../Query.js";
 import { SqliteFormatter } from "../sqlite/SqliteFormatter.js";
+import { SqliteSchema } from "../sqlite/SqliteSchema.js";
 var Sqlite3Driver = class extends Driver.Async {
   constructor(db) {
-    super();
+    super(new SqliteFormatter());
     this.db = db;
   }
-  formatter = new SqliteFormatter();
   lock;
-  async execute(query) {
+  async executeQuery(query) {
     await this.lock;
+    return super.executeQuery(query);
+  }
+  rows([sql, params]) {
+    return new Promise((resolve, reject) => {
+      const stmt = this.db.prepare(sql);
+      stmt.all(params, (err, rows) => {
+        if (err)
+          reject(err);
+        else
+          resolve(rows);
+      });
+    });
+  }
+  async values(stmt) {
+    const rows = await this.rows(stmt);
+    return rows.map(Object.values);
+  }
+  execute([sql, params]) {
     return new Promise((resolve, reject) => {
-      const [sql, params] = this.formatter.compile(query);
       const stmt = this.db.prepare(sql);
-      if ("selection" in query) {
-        stmt.all(params, (err, rows) => {
-          const res = rows.map((row) => JSON.parse(row.result).result);
-          if (err)
-            reject(err);
-          else
-            resolve(query.singleResult ? res[0] : res);
-        });
-      } else if (query.type === QueryType.Raw) {
-        switch (query.expectedReturn) {
-          case "row":
-            return stmt.get(params, (err, row) => {
-              if (err)
-                reject(err);
-              else
-                resolve(row);
-            });
-          case "rows":
-            return stmt.all(params, (err, rows) => {
-              if (err)
-                reject(err);
-              else
-                resolve(rows);
-            });
-          default:
-            stmt.run(params, (err) => {
-              if (err)
-                reject(err);
-              else
-                resolve(void 0);
-            });
-            return void 0;
-        }
-      } else {
-        stmt.run(params, function(err) {
-          if (err)
-            reject(err);
-          else
-            resolve({ rowsAffected: this.changes });
-        });
-      }
+      stmt.run(params, (err) => {
+        if (err)
+          reject(err);
+        else
+          resolve();
+      });
     });
   }
+  mutate([sql, params]) {
+    return new Promise((resolve, reject) => {
+      const stmt = this.db.prepare(sql);
+      stmt.run(params, function(err) {
+        if (err)
+          reject(err);
+        else
+          resolve({ rowsAffected: this.changes });
+      });
+    });
+  }
+  async schemaInstructions(tableName) {
+    const columnData = await this.rows(
+      SqliteSchema.tableData(tableName).compile(this.formatter)
+    );
+    const indexData = await this.rows(
+      SqliteSchema.indexData(tableName).compile(this.formatter)
+    );
+    return SqliteSchema.createInstructions(columnData, indexData);
+  }
   isolate() {
     const connection = new Sqlite3Driver(this.db);
     let release, trigger = new Promise((resolve) => {

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 export * from './Column';
 export * from './Cursor';
+export * from './Driver';
 export * from './Expr';
 export * from './Fields';
 export * from './Formatter';
@@ -9,6 +10,7 @@ export * from './OrderBy';
 export * from './Param';
 export * from './Query';
 export * from './Sanitizer';
+export * from './Schema';
 export * from './Selection';
 export * from './Statement';
 export * from './Table';

package/dist/index.js

@@ -1,6 +1,7 @@
 // src/index.ts
 export * from "./Column.js";
 export * from "./Cursor.js";
+export * from "./Driver.js";
 export * from "./Expr.js";
 export * from "./Fields.js";
 export * from "./Formatter.js";
@@ -10,6 +11,7 @@ export * from "./OrderBy.js";
 export * from "./Param.js";
 export * from "./Query.js";
 export * from "./Sanitizer.js";
+export * from "./Schema.js";
 export * from "./Selection.js";
 export * from "./Statement.js";
 export * from "./Table.js";

package/dist/sqlite/SqliteFormatter.d.ts

@@ -2,7 +2,7 @@ import { Formatter } from '../Formatter';
 import { Statement } from '../Statement';
 export declare class SqliteFormatter extends Formatter {
     escapeValue(value: any): string;
-    escapeIdent(input: string): string;
+    escapeIdentifier(input: string): string;
     escapeString(input: string): string;
     formatSqlAccess(on: Statement, field: string): Statement;
     formatJsonAccess(on: Statement, field: string): Statement;

package/dist/sqlite/SqliteFormatter.js

@@ -23,7 +23,7 @@ var SqliteFormatter = class extends Formatter {
       return this.escapeString(value);
     return "json(" + this.escapeString(JSON.stringify(value)) + ")";
   }
-  escapeIdent(input) {
+  escapeIdentifier(input) {
     return escapeWithin(input, "`");
   }
   escapeString(input) {

package/dist/sqlite/SqliteSchema.d.ts

@@ -0,0 +1,24 @@
+import { SchemaInstructions } from '../Schema';
+import { Statement } from '../Statement';
+export declare namespace SqliteSchema {
+    type Column = {
+        cid: number;
+        name: string;
+        type: string;
+        notnull: number;
+        dflt_value: string | null;
+        pk: number;
+    };
+    interface Index {
+        type: 'index';
+        name: string;
+        tbl_name: string;
+        rootpage: number;
+        sql: string;
+    }
+    function tableData(tableName: string): Statement;
+    function indexData(tableName: string): Statement;
+    function createInstructions(columnData: Array<Column>, indexData: Array<Index>): SchemaInstructions | undefined;
+    function columnInstruction(column: Column): [string, string];
+    function indexInstruction(index: Index): [string, string];
+}

package/dist/sqlite/SqliteSchema.js

@@ -0,0 +1,40 @@
+// src/sqlite/SqliteSchema.ts
+import { Statement, identifier } from "../Statement.js";
+import { SqliteFormatter } from "./SqliteFormatter.js";
+var SqliteSchema;
+((SqliteSchema2) => {
+  const formatter = new SqliteFormatter();
+  function tableData(tableName) {
+    return Statement.tag`select * from pragma_table_info(${tableName}) order by cid`;
+  }
+  SqliteSchema2.tableData = tableData;
+  function indexData(tableName) {
+    return Statement.tag`select * from sqlite_master where type='index' and tbl_name=${tableName}`;
+  }
+  SqliteSchema2.indexData = indexData;
+  function createInstructions(columnData, indexData2) {
+    if (columnData.length === 0 && indexData2.length === 0)
+      return void 0;
+    const columns = columnData.map(columnInstruction);
+    const indexes = indexData2.map(indexInstruction);
+    return {
+      columns: Object.fromEntries(columns),
+      indexes: Object.fromEntries(indexes)
+    };
+  }
+  SqliteSchema2.createInstructions = createInstructions;
+  function columnInstruction(column) {
+    return [
+      column.name,
+      identifier(column.name).add(column.type.toLowerCase()).addIf(column.pk === 1, "primary key").addIf(column.notnull === 1, "not null").addIf(column.dflt_value !== null, column.dflt_value).compile(formatter)[0]
+    ];
+  }
+  SqliteSchema2.columnInstruction = columnInstruction;
+  function indexInstruction(index) {
+    return [index.name, index.sql];
+  }
+  SqliteSchema2.indexInstruction = indexInstruction;
+})(SqliteSchema || (SqliteSchema = {}));
+export {
+  SqliteSchema
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rado",
-  "version": "0.0.0",
+  "version": "0.1.1",
   "license": "MIT",
   "type": "module",
   "exports": {