rado 0.0.0 → 0.1.0

package/dist/Query.d.ts

@@ -1,6 +1,7 @@
+import { ColumnData } from './Column';
 import { ExprData } from './Expr';
 import { OrderBy } from './OrderBy';
-import { TableData } from './Table';
+import { Index, Schema } from './Schema';
 import { Target } from './Target';
 export declare const enum QueryType {
     Insert = "Insert",
@@ -8,11 +9,14 @@ export declare const enum QueryType {
     Update = "Update",
     Delete = "Delete",
     CreateTable = "CreateTable",
+    CreateIndex = "CreateIndex",
+    DropIndex = "DropIndex",
+    AlterTable = "AlterTable",
     Batch = "Batch",
     Transaction = "Transaction",
     Raw = "Raw"
 }
-export type Query<T = any> = Query.Insert | Query.Select | Query.Update | Query.Delete | Query.CreateTable | Query.Batch | Query.Transaction | Query.Raw;
+export type Query<T = any> = Query.Insert | Query.Select | Query.Update | Query.Delete | Query.CreateTable | Query.CreateIndex | Query.DropIndex | Query.AlterTable | Query.Batch | Query.Transaction | Query.Raw;
 export declare namespace Query {
     interface QueryBase {
         limit?: number;
@@ -27,42 +31,52 @@ export declare namespace Query {
     }
     interface Insert extends QueryBase {
         type: QueryType.Insert;
-        into: TableData;
+        into: Schema;
         data: Array<any>;
     }
-    function Insert<T>(insert: Omit<Insert, 'type'>): Query<T>;
+    function Insert(insert: Omit<Insert, 'type'>): Query.Insert;
     interface Select extends QueryBase {
         type: QueryType.Select;
         selection: ExprData;
         from: Target;
     }
-    function Select<T>(select: Omit<Select, 'type'>): Query<T>;
+    function Select(select: Omit<Select, 'type'>): Query.Select;
     interface Update extends QueryBase {
         type: QueryType.Update;
-        table: TableData;
+        table: Schema;
         set?: Record<string, any>;
     }
-    function Update<T>(update: Omit<Update, 'type'>): Query<{
-        rowsAffected: number;
-    }>;
+    function Update(update: Omit<Update, 'type'>): Query.Update;
     interface Delete extends QueryBase {
         type: QueryType.Delete;
-        table: TableData;
+        table: Schema;
     }
-    function Delete<T>(del: Omit<Delete, 'type'>): Query<{
-        rowsAffected: number;
-    }>;
+    function Delete(del: Omit<Delete, 'type'>): Query.Delete;
     interface CreateTable extends QueryBase {
         type: QueryType.CreateTable;
-        table: TableData;
+        table: Schema;
         ifNotExists?: boolean;
     }
-    function CreateTable<T>(create: Omit<CreateTable, 'type'>): Query<void>;
+    function CreateTable(create: Omit<CreateTable, 'type'>): Query.CreateTable;
+    interface CreateIndex extends QueryBase {
+        type: QueryType.CreateIndex;
+        table: Schema;
+        index: Index;
+        ifNotExists?: boolean;
+    }
+    function CreateIndex(create: Omit<CreateIndex, 'type'>): Query.CreateIndex;
+    interface DropIndex extends QueryBase {
+        type: QueryType.DropIndex;
+        table: Schema;
+        index: Index;
+        ifExists?: boolean;
+    }
+    function DropIndex(drop: Omit<DropIndex, 'type'>): Query.DropIndex;
     interface Batch extends QueryBase {
         type: QueryType.Batch;
         queries: Array<Query<any>>;
     }
-    function Batch<T>(batch: Omit<Batch, 'type'>): Query<void>;
+    function Batch(batch: Omit<Batch, 'type'>): Query.Batch;
     enum TransactionOperation {
         Begin = "Begin",
         Commit = "Commit",
@@ -73,7 +87,7 @@ export declare namespace Query {
         id: string;
         op: TransactionOperation;
     }
-    function Transaction<T>(transaction: Omit<Transaction, 'type'>): Query<T>;
+    function Transaction(transaction: Omit<Transaction, 'type'>): Query.Transaction;
     type RawReturn = 'row' | 'rows' | undefined;
     interface Raw extends QueryBase {
         type: QueryType.Raw;
@@ -81,5 +95,13 @@ export declare namespace Query {
         strings: ReadonlyArray<string>;
         params: Array<any>;
     }
-    function Raw<T>(raw: Omit<Raw, 'type'>): Query<T>;
+    function Raw(raw: Omit<Raw, 'type'>): Query.Raw;
+    interface AlterTable extends QueryBase {
+        type: QueryType.AlterTable;
+        table: Schema;
+        alterColumn?: ColumnData;
+        addColumn?: ColumnData;
+        dropColumn?: string;
+    }
+    function AlterTable(alter: Omit<AlterTable, 'type'>): Query.AlterTable;
 }

package/dist/Query.js

@@ -5,6 +5,9 @@ var QueryType = /* @__PURE__ */ ((QueryType2) => {
   QueryType2["Update"] = "Update";
   QueryType2["Delete"] = "Delete";
   QueryType2["CreateTable"] = "CreateTable";
+  QueryType2["CreateIndex"] = "CreateIndex";
+  QueryType2["DropIndex"] = "DropIndex";
+  QueryType2["AlterTable"] = "AlterTable";
   QueryType2["Batch"] = "Batch";
   QueryType2["Transaction"] = "Transaction";
   QueryType2["Raw"] = "Raw";
@@ -32,6 +35,14 @@ var Query;
     return { type: "CreateTable" /* CreateTable */, ...create };
   }
   Query2.CreateTable = CreateTable;
+  function CreateIndex(create) {
+    return { type: "CreateIndex" /* CreateIndex */, ...create };
+  }
+  Query2.CreateIndex = CreateIndex;
+  function DropIndex(drop) {
+    return { type: "DropIndex" /* DropIndex */, ...drop };
+  }
+  Query2.DropIndex = DropIndex;
   function Batch(batch) {
     return { type: "Batch" /* Batch */, ...batch };
   }
@@ -50,6 +61,10 @@ var Query;
     return { type: "Raw" /* Raw */, ...raw };
   }
   Query2.Raw = Raw;
+  function AlterTable(alter) {
+    return { type: "AlterTable" /* AlterTable */, ...alter };
+  }
+  Query2.AlterTable = AlterTable;
 })(Query || (Query = {}));
 export {
   Query,

package/dist/Sanitizer.d.ts

@@ -1,4 +1,4 @@
 export interface Sanitizer {
     escapeValue(value: any): string;
-    escapeIdent(ident: string): string;
+    escapeIdentifier(ident: string): string;
 }

package/dist/Schema.d.ts

@@ -0,0 +1,23 @@
+import { ColumnData } from './Column';
+import { ExprData } from './Expr';
+import { Formatter } from './Formatter';
+import { Query } from './Query';
+export interface Index {
+    name: string;
+    on: Array<ExprData>;
+    where?: ExprData;
+}
+export interface Schema {
+    name: string;
+    alias?: string;
+    columns: Record<string, ColumnData>;
+    indexes: Record<string, Index>;
+}
+export interface SchemaInstructions {
+    columns: Record<string, string>;
+    indexes: Record<string, string>;
+}
+export declare namespace Schema {
+    function create(schema: Schema): Query.Batch;
+    function upgrade(formatter: Formatter, local: SchemaInstructions, schema: Schema): Array<Query>;
+}

package/dist/Schema.js

@@ -0,0 +1,60 @@
+// src/Schema.ts
+import { Query } from "./Query.js";
+var Schema;
+((Schema2) => {
+  function create(schema) {
+    const queries = [];
+    queries.push(Query.CreateTable({ table: schema, ifNotExists: true }));
+    for (const index of Object.values(schema.indexes))
+      queries.push(Query.CreateIndex({ table: schema, index, ifNotExists: true }));
+    return Query.Batch({ queries });
+  }
+  Schema2.create = create;
+  function upgrade(formatter, local, schema) {
+    const columnNames = /* @__PURE__ */ new Set([
+      ...Object.keys(local.columns),
+      ...Object.keys(schema.columns)
+    ]);
+    const res = [];
+    for (const columnName of columnNames) {
+      const localInstruction = local.columns[columnName];
+      const schemaCol = schema.columns[columnName];
+      if (!localInstruction) {
+        res.push(Query.AlterTable({ table: schema, addColumn: schemaCol }));
+      } else if (!schemaCol) {
+        res.push(Query.AlterTable({ table: schema, dropColumn: columnName }));
+      } else {
+        const [instruction] = formatter.formatColumn({ ...schemaCol, references: void 0 }).compile(formatter);
+        if (localInstruction !== instruction) {
+          res.push(Query.AlterTable({ table: schema, alterColumn: schemaCol }));
+        }
+      }
+    }
+    const indexNames = /* @__PURE__ */ new Set([
+      ...Object.keys(local.indexes),
+      ...Object.keys(schema.indexes)
+    ]);
+    for (const indexName of indexNames) {
+      const localInstruction = local.indexes[indexName];
+      const schemaIndex = schema.indexes[indexName];
+      if (!localInstruction) {
+        res.push(Query.CreateIndex({ table: schema, index: schemaIndex }));
+      } else if (!schemaIndex) {
+        res.push(Query.DropIndex({ table: schema, index: schemaIndex }));
+      } else {
+        const [instruction] = formatter.formatCreateIndex(
+          Query.CreateIndex({ table: schema, index: schemaIndex })
+        ).compile(formatter);
+        if (localInstruction !== instruction) {
+          res.push(Query.DropIndex({ table: schema, index: schemaIndex }));
+          res.push(Query.CreateIndex({ table: schema, index: schemaIndex }));
+        }
+      }
+    }
+    return res;
+  }
+  Schema2.upgrade = upgrade;
+})(Schema || (Schema = {}));
+export {
+  Schema
+};

package/dist/Statement.d.ts

@@ -21,7 +21,7 @@ export declare class Statement {
     constructor(tokens: Array<Token>);
     concat(...tokens: Array<Token | Statement>): Statement;
     static create(from: string | Statement): Statement;
-    static ofTemplate(strings: ReadonlyArray<string>, params: Array<any>): Statement;
+    static tag(strings: ReadonlyArray<string>, ...params: Array<any>): Statement;
     space(): Statement;
     call(method: string, ...args: Array<Statement>): Statement;
     addCall(method: string, ...args: Array<Statement>): Statement;
@@ -41,7 +41,10 @@ export declare class Statement {
     separated(input: Array<Statement>, separator?: string): Statement;
     addSeparated(input: Array<Statement>, separator?: string): Statement;
     isEmpty(): boolean;
-    compile(sanitizer: Sanitizer, formatInline?: boolean): [string, Array<any>];
+    compile(sanitizer: Sanitizer, formatInline?: boolean): Statement.Compiled;
+}
+export declare namespace Statement {
+    type Compiled = [sql: string, params: Array<any>];
 }
 export declare function newline(): Statement;
 export declare function raw(raw: string): Statement;

package/dist/Statement.js

@@ -37,7 +37,7 @@ var Statement = class {
   static create(from) {
     return typeof from === "string" ? raw(from) : from;
   }
-  static ofTemplate(strings, params) {
+  static tag(strings, ...params) {
     return new Statement(
       strings.flatMap((s, i) => [Token.Raw(s), Token.Value(params[i])]).slice(0, -1)
     );
@@ -126,7 +126,7 @@ var Statement = class {
             sql += token.data;
           break;
         case "Identifier" /* Identifier */:
-          sql += sanitizer.escapeIdent(token.data);
+          sql += sanitizer.escapeIdentifier(token.data);
           break;
         case "Value" /* Value */:
           if (formatInline) {

package/dist/Table.d.ts

@@ -1,18 +1,13 @@
-import { Column, ColumnData } from './Column';
+import { Column } from './Column';
 import { Cursor } from './Cursor';
 import { Expr } from './Expr';
 import { Fields } from './Fields';
+import { Schema } from './Schema';
 import { Update } from './Update';
-export interface TableData {
-    name: string;
-    alias?: string;
-    columns: Record<string, ColumnData>;
-    indexes?: Record<string, Array<Expr<any>>>;
-}
 export declare class Table<T> extends Cursor.SelectMultiple<T> {
     /** @internal */
     protected __tableType: T;
-    constructor(data: TableData);
+    constructor(schema: Schema);
     insertOne(record: Table.Insert<T>): Cursor.Batch<T>;
     insertAll(data: Array<Table.Insert<T>>): Cursor.InsertValues;
     set(data: Update<T>): Cursor.Update<T>;
@@ -20,8 +15,7 @@ export declare class Table<T> extends Cursor.SelectMultiple<T> {
     as(alias: string): Table<T> & Fields<T>;
     get(name: string): Expr<any>;
     toExpr(): Expr<T>;
-    /** @internal */
-    data(): TableData;
+    schema(): Schema;
 }
 export declare namespace Table {
     type Intersection<A, B> = A & B extends infer U ? {
@@ -45,6 +39,10 @@ export interface TableOptions<T> {
     columns: {
         [K in keyof T]: Column<T[K]>;
     };
+    indexes?: (this: Fields<T>) => Record<string, {
+        on: Array<Expr<any>>;
+        where?: Expr<boolean>;
+    }>;
 }
 export declare function table<T extends {}>(options: TableOptions<T>): Table<T> & Fields<T>;
 export declare namespace table {

package/dist/Table.js

@@ -4,19 +4,19 @@ import { Expr, ExprData } from "./Expr.js";
 import { Query } from "./Query.js";
 import { Target } from "./Target.js";
 var Table = class extends Cursor.SelectMultiple {
-  constructor(data) {
+  constructor(schema) {
     super(
       Query.Select({
-        from: Target.Table(data),
-        selection: ExprData.Row(Target.Table(data))
+        from: Target.Table(schema),
+        selection: ExprData.Row(Target.Table(schema))
       })
     );
-    Object.defineProperty(this, "data", {
+    Object.defineProperty(this, "schema", {
       enumerable: false,
-      value: () => data
+      value: () => schema
     });
-    if (data.columns)
-      for (const column of Object.keys(data.columns)) {
+    if (schema.columns)
+      for (const column of Object.keys(schema.columns)) {
         Object.defineProperty(this, column, {
           enumerable: true,
           get: () => this.get(column)
@@ -31,49 +31,65 @@ var Table = class extends Cursor.SelectMultiple {
   insertOne(record) {
     return new Cursor.Batch([
       Query.Insert({
-        into: this.data(),
+        into: this.schema(),
         data: [record],
-        selection: ExprData.Row(Target.Table(this.data())),
+        selection: ExprData.Row(Target.Table(this.schema())),
         singleResult: true
       })
     ]);
   }
   insertAll(data) {
-    return new Cursor.Insert(this.data()).values(...data);
+    return new Cursor.Insert(this.schema()).values(...data);
   }
   set(data) {
     return new Cursor.Update(
       Query.Update({
-        table: this.data()
+        table: this.schema()
       })
     ).set(data);
   }
   createTable() {
-    return new Cursor.Create(this.data());
+    return new Cursor.Create(this.schema());
   }
   as(alias) {
-    return new Table({ ...this.data(), alias });
+    return new Table({ ...this.schema(), alias });
   }
   get(name) {
     return new Expr(ExprData.Field(this.toExpr().expr, name));
   }
   toExpr() {
-    return new Expr(ExprData.Row(Target.Table(this.data())));
+    return new Expr(ExprData.Row(Target.Table(this.schema())));
   }
-  /** @internal */
-  data() {
+  schema() {
     throw new Error("Not implemented");
   }
 };
 function table(options) {
-  return new Table({
+  const schema = {
     ...options,
     columns: Object.fromEntries(
       Object.entries(options.columns).map(([key, column]) => {
         const { data } = column;
         return [key, { ...data, name: data.name || key }];
       })
-    )
+    ),
+    indexes: {}
+  };
+  const indexes = Object.fromEntries(
+    Object.entries(
+      options.indexes ? options.indexes.call(
+        new Expr(ExprData.Row(Target.Table(schema)))
+      ) : {}
+    ).map(([key, index]) => {
+      return [
+        key,
+        { name: key, on: index.on.map(ExprData.create), where: index.where?.expr }
+      ];
+    })
+  );
+  return new Table({
+    ...schema,
+    indexes
   });
 }
 export {

package/dist/Target.d.ts

@@ -1,5 +1,5 @@
 import { ExprData } from './Expr';
-import { TableData } from './Table';
+import { Schema } from './Schema';
 export declare const enum TargetType {
     Each = "Each",
     Table = "Table",
@@ -15,9 +15,9 @@ export declare namespace Target {
     function Each(expr: ExprData, alias: string): Each;
     interface Table {
         type: TargetType.Table;
-        table: TableData;
+        table: Schema;
     }
-    function Table(table: TableData): Table;
+    function Table(table: Schema): Table;
     interface Join {
         type: TargetType.Join;
         left: Target;
@@ -26,5 +26,5 @@ export declare namespace Target {
         on: ExprData;
     }
     function Join(left: Target, right: Target, joinType: 'left' | 'inner', on: ExprData): Join;
-    function source(from: Target): TableData | undefined;
+    function source(from: Target): Schema | undefined;
 }

package/dist/driver/better-sqlite3.d.ts

@@ -1,12 +1,17 @@
 import type { Database } from 'better-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 BetterSqlite3Driver 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): BetterSqlite3Driver;

package/dist/driver/better-sqlite3.js

@@ -1,34 +1,36 @@
 // 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) {
+    try {
+      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);
+    } catch (e) {
+      return void 0;
     }
   }
   export() {

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,43 +1,46 @@
 // 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) {
+    try {
+      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);
+    } catch (e) {
+      return void 0;
     }
   }
   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;