rado 0.0.0 → 0.1.0

package/dist/driver/sqlite3.js

@@ -1,62 +1,67 @@
 // 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) {
+    try {
+      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);
+    } catch (e) {
+      return void 0;
+    }
+  }
   isolate() {
     const connection = new Sqlite3Driver(this.db);
     let release, trigger = new Promise((resolve) => {

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;
+    function columnInstruction(column: Column): [string, string];
+    function indexInstruction(index: Index): [string, string];
+}

package/dist/sqlite/SqliteSchema.js

@@ -0,0 +1,38 @@
+// 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) {
+    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.0",
   "license": "MIT",
   "type": "module",
   "exports": {