rado 0.0.0 → 0.1.1

package/dist/Column.d.ts

@@ -1,28 +1,33 @@
+import { Expr, ExprData } from './Expr';
 export declare const enum ColumnType {
     String = "String",
     Integer = "Integer",
     Number = "Number",
     Boolean = "Boolean",
-    Object = "Object",
-    Array = "Array"
+    Json = "Json"
 }
-export interface ColumnData {
+interface PartialColumnData {
     type: ColumnType;
     name?: string;
     nullable?: boolean;
+    defaultValue?: any;
     autoIncrement?: boolean;
     primaryKey?: boolean;
     unique?: boolean;
-    defaultValue?: any;
-    generated?: boolean;
+    references?: ExprData;
+}
+export interface ColumnData extends PartialColumnData {
+    type: ColumnType;
+    name: string;
 }
 export declare class Column<T = any> {
-    data: ColumnData;
-    constructor(data: ColumnData);
+    data: PartialColumnData;
+    constructor(data: PartialColumnData);
     name(name: string): Column<T>;
     nullable(): Column<T | null>;
     autoIncrement(): Column<T & Column.Optional>;
     primaryKey(): Column<T & Column.Optional>;
+    references(column: Expr<T>): Column<any>;
     unique(): Column<T>;
     defaultValue(value: T): Column<T & Column.Optional>;
 }
@@ -41,3 +46,4 @@ export declare const column: {
     object<T_4 extends object = object>(): Column<T_4>;
     array<T_5 = any>(): Column<T_5[]>;
 };
+export {};

package/dist/Column.js

@@ -1,11 +1,11 @@
 // src/Column.ts
+import { ExprData } from "./Expr.js";
 var ColumnType = /* @__PURE__ */ ((ColumnType2) => {
   ColumnType2["String"] = "String";
   ColumnType2["Integer"] = "Integer";
   ColumnType2["Number"] = "Number";
   ColumnType2["Boolean"] = "Boolean";
-  ColumnType2["Object"] = "Object";
-  ColumnType2["Array"] = "Array";
+  ColumnType2["Json"] = "Json";
   return ColumnType2;
 })(ColumnType || {});
 var Column = class {
@@ -24,6 +24,9 @@ var Column = class {
   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 });
   }
@@ -45,10 +48,10 @@ var column = {
     return new Column({ type: "Boolean" /* Boolean */ });
   },
   object() {
-    return new Column({ type: "Object" /* Object */ });
+    return new Column({ type: "Json" /* Json */ });
   },
   array() {
-    return new Column({ type: "Array" /* Array */ });
+    return new Column({ type: "Json" /* Json */ });
   }
 };
 export {

package/dist/Cursor.d.ts

@@ -1,8 +1,9 @@
 import { EV, Expr } from './Expr';
 import { OrderBy } from './OrderBy';
 import { Query } from './Query';
+import { Schema } from './Schema';
 import { Selection } from './Selection';
-import { Table, TableData } from './Table';
+import { Table } from './Table';
 import { Update as UpdateSet } from './Update';
 export declare class Cursor<T> {
     /** @internal */
@@ -39,13 +40,13 @@ export declare namespace Cursor {
         returning<X extends Selection>(selection: X): InsertValuesReturning<Selection.Infer<X>>;
     }
     class Insert<T> {
-        protected into: TableData;
-        constructor(into: TableData);
+        protected into: Schema;
+        constructor(into: Schema);
         values(...data: Array<Table.Insert<T>>): InsertValues;
     }
     class Create extends Cursor<void> {
-        protected table: TableData;
-        constructor(table: TableData);
+        protected table: Schema;
+        constructor(table: Schema);
     }
     class Batch<T = void> extends Cursor<T> {
         protected queries: Array<Query>;

package/dist/Cursor.js

@@ -2,6 +2,7 @@
 import { Expr, ExprData } from "./Expr.js";
 import { Functions } from "./Functions.js";
 import { Query } from "./Query.js";
+import { Schema } from "./Schema.js";
 import { Target } from "./Target.js";
 var Cursor = class {
   constructor(query) {
@@ -75,7 +76,7 @@ var Cursor = class {
   Cursor2.Insert = Insert;
   class Create extends Cursor2 {
     constructor(table) {
-      super(Query.CreateTable({ table, ifNotExists: true }));
+      super(Schema.create(table));
       this.table = table;
     }
   }
@@ -97,7 +98,7 @@ var Cursor = class {
         ...query,
         from: Target.Join(
           query.from,
-          Target.Table(that.data()),
+          Target.Table(that.schema()),
           "left",
           Expr.and(...on).expr
         )
@@ -109,7 +110,7 @@ var Cursor = class {
         ...query,
         from: Target.Join(
           query.from,
-          Target.Table(that.data()),
+          Target.Table(that.schema()),
           "inner",
           Expr.and(...on).expr
         )
@@ -161,7 +162,7 @@ var Cursor = class {
         ...query,
         from: Target.Join(
           query.from,
-          Target.Table(that.data()),
+          Target.Table(that.schema()),
           "left",
           Expr.and(...on).expr
         )
@@ -173,7 +174,7 @@ var Cursor = class {
         ...query,
         from: Target.Join(
           query.from,
-          Target.Table(that.data()),
+          Target.Table(that.schema()),
           "inner",
           Expr.and(...on).expr
         )

package/dist/Driver.d.ts

@@ -1,49 +1,78 @@
 import { Cursor } from './Cursor';
+import { Formatter } from './Formatter';
 import { Query } from './Query';
+import { SchemaInstructions } from './Schema';
+import { Statement } from './Statement';
+import { Table } from './Table';
 declare class Callable extends Function {
     constructor(fn: Function);
 }
 declare abstract class DriverBase extends Callable {
-    constructor();
+    formatter: Formatter;
+    constructor(formatter: Formatter);
     all(strings: TemplateStringsArray, ...params: Array<any>): any;
     get(strings: TemplateStringsArray, ...params: Array<any>): any;
     executeTemplate(expectedReturn: Query.RawReturn, strings: TemplateStringsArray, ...params: Array<any>): any;
     abstract executeQuery(query: Query<any>): any;
 }
+interface SyncDriver {
+    <T>(query: Cursor<T>): T;
+    (strings: TemplateStringsArray, ...values: any[]): any;
+}
+declare abstract class SyncDriver extends DriverBase {
+    transactionId: number;
+    abstract rows(stmt: Statement.Compiled): Array<object>;
+    abstract values(stmt: Statement.Compiled): Array<Array<any>>;
+    abstract execute(stmt: Statement.Compiled): void;
+    abstract mutate(stmt: Statement.Compiled): {
+        rowsAffected: number;
+    };
+    abstract schemaInstructions(tableName: string): SchemaInstructions | undefined;
+    migrateSchema(...tables: Array<Table<any>>): unknown;
+    executeQuery<T>(query: Query<T>): T;
+    all<T>(strings: TemplateStringsArray, ...params: Array<any>): Array<T>;
+    get<T>(strings: TemplateStringsArray, ...params: Array<any>): T;
+    transaction<T>(run: (query: SyncDriver) => T): T;
+    toAsync(): SyncWrapper;
+}
+interface AsyncDriver {
+    <T>(query: Cursor<T>): Promise<T>;
+    (strings: TemplateStringsArray, ...values: any[]): Promise<any>;
+}
+declare abstract class AsyncDriver extends DriverBase {
+    transactionId: number;
+    abstract isolate(): [connection: AsyncDriver, release: () => Promise<void>];
+    abstract rows(stmt: Statement.Compiled): Promise<Array<object>>;
+    abstract values(stmt: Statement.Compiled): Promise<Array<Array<any>>>;
+    abstract execute(stmt: Statement.Compiled): Promise<void>;
+    abstract mutate(stmt: Statement.Compiled): Promise<{
+        rowsAffected: number;
+    }>;
+    abstract schemaInstructions(tableName: string): Promise<SchemaInstructions | undefined>;
+    migrateSchema(...tables: Array<Table<any>>): Promise<unknown>;
+    executeQuery<T>(query: Query<T>): Promise<T>;
+    all<T>(strings: TemplateStringsArray, ...params: Array<any>): Promise<Array<T>>;
+    get<T>(strings: TemplateStringsArray, ...params: Array<any>): Promise<T>;
+    transaction<T>(run: (query: AsyncDriver) => T): Promise<T>;
+}
+declare class SyncWrapper extends AsyncDriver {
+    private sync;
+    lock: Promise<void> | undefined;
+    constructor(sync: SyncDriver);
+    executeQuery<T>(query: Query<T>): Promise<T>;
+    rows(stmt: Statement.Compiled): Promise<Array<object>>;
+    values(stmt: Statement.Compiled): Promise<Array<Array<any>>>;
+    execute(stmt: Statement.Compiled): Promise<void>;
+    mutate(stmt: Statement.Compiled): Promise<{
+        rowsAffected: number;
+    }>;
+    schemaInstructions(tableName: string): Promise<SchemaInstructions | undefined>;
+    isolate(): [connection: AsyncDriver, release: () => Promise<void>];
+}
 export declare namespace Driver {
-    export interface Sync {
-        <T>(query: Cursor<T>): T;
-        (strings: TemplateStringsArray, ...values: any[]): any;
-    }
-    export abstract class Sync extends DriverBase {
-        transactionId: number;
-        abstract execute(query: Query): any;
-        executeQuery<T>(query: Query<T>): T;
-        all<T>(strings: TemplateStringsArray, ...params: Array<any>): Array<T>;
-        get<T>(strings: TemplateStringsArray, ...params: Array<any>): T;
-        transaction<T>(run: (query: Sync) => T): T;
-        toAsync(): SyncWrapper;
-    }
-    export interface Async {
-        <T>(query: Cursor<T>): Promise<T>;
-        (strings: TemplateStringsArray, ...values: any[]): Promise<any>;
-    }
-    export abstract class Async extends DriverBase {
-        transactionId: number;
-        abstract execute(query: Query): Promise<any>;
-        abstract isolate(): [connection: Async, release: () => Promise<void>];
-        executeQuery<T>(query: Query<T>): Promise<T>;
-        all<T>(strings: TemplateStringsArray, ...params: Array<any>): Promise<Array<T>>;
-        get<T>(strings: TemplateStringsArray, ...params: Array<any>): Promise<T>;
-        transaction<T>(run: (query: Async) => T): Promise<T>;
-    }
-    class SyncWrapper extends Async {
-        private sync;
-        lock: Promise<void> | undefined;
-        constructor(sync: Sync);
-        execute<T>(query: Query<T>): Promise<T>;
-        isolate(): [connection: Async, release: () => Promise<void>];
-    }
-    export {};
+    type Sync = SyncDriver;
+    const Sync: typeof SyncDriver;
+    type Async = AsyncDriver;
+    const Async: typeof AsyncDriver;
 }
 export {};

package/dist/Driver.js

@@ -1,6 +1,7 @@
 // src/Driver.ts
 import { Cursor } from "./Cursor.js";
 import { Query, QueryType } from "./Query.js";
+import { Schema } from "./Schema.js";
 var Callable = class extends Function {
   constructor(fn) {
     super();
@@ -12,13 +13,14 @@ var Callable = class extends Function {
   }
 };
 var DriverBase = class extends Callable {
-  constructor() {
+  constructor(formatter) {
     super((...args) => {
       const [input, ...rest] = args;
       if (input instanceof Cursor)
         return this.executeQuery(input.query());
       return this.executeTemplate(void 0, input, ...rest);
     });
+    this.formatter = formatter;
   }
   all(strings, ...params) {
     return this.executeTemplate("rows", strings, ...params);
@@ -32,113 +34,208 @@ var DriverBase = class extends Callable {
     return this.executeQuery(Query.Raw({ strings, params, expectedReturn }));
   }
 };
-var Driver;
-((Driver2) => {
-  class Sync extends DriverBase {
-    transactionId = 0;
-    executeQuery(query) {
-      switch (query.type) {
-        case QueryType.Batch:
-          let result;
-          const stmts = query.queries;
-          for (const query2 of stmts)
-            result = this.execute(query2);
-          return result;
-        default:
-          return this.execute(query);
+var SyncDriver = class extends DriverBase {
+  transactionId = 0;
+  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);
       }
     }
-    all(strings, ...params) {
-      return super.all(strings, ...params);
-    }
-    get(strings, ...params) {
-      return super.get(strings, ...params);
+    return this.executeQuery(Query.Batch({ queries }));
+  }
+  executeQuery(query) {
+    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 stmt = this.formatter.compile(query);
+        if ("selection" in query) {
+          const res = this.values(stmt).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 this.rows(stmt)[0];
+            case "rows":
+              return this.rows(stmt);
+            default:
+              this.execute(stmt);
+              return void 0;
+          }
+        } else {
+          return this.mutate(stmt);
+        }
     }
-    transaction(run) {
-      const id = `t${this.transactionId++}`;
-      this.execute(
-        Query.Transaction({ op: Query.TransactionOperation.Begin, id })
+  }
+  all(strings, ...params) {
+    return super.all(strings, ...params);
+  }
+  get(strings, ...params) {
+    return super.get(strings, ...params);
+  }
+  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 })
       );
-      try {
-        const res = run(this);
-        this.execute(
-          Query.Transaction({ op: Query.TransactionOperation.Commit, id })
-        );
-        return res;
-      } catch (e) {
-        this.execute(
-          Query.Transaction({ op: Query.TransactionOperation.Rollback, id })
-        );
-        throw e;
-      }
+      return res;
+    } catch (e) {
+      this.executeQuery(
+        Query.Transaction({ op: Query.TransactionOperation.Rollback, id })
+      );
+      throw e;
     }
-    toAsync() {
-      return new SyncWrapper(this);
+  }
+  toAsync() {
+    return new SyncWrapper(this);
+  }
+};
+var AsyncDriver = class extends DriverBase {
+  transactionId = 0;
+  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 }));
   }
-  Driver2.Sync = Sync;
-  class Async extends DriverBase {
-    transactionId = 0;
-    async executeQuery(query) {
-      switch (query.type) {
-        case QueryType.Batch:
-          let result;
-          const stmts = query.queries;
+  async executeQuery(query) {
+    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 this.execute(query2);
+            result = await cnx.executeQuery(query2);
           return result;
-        default:
-          return this.execute(query);
-      }
-    }
-    all(strings, ...params) {
-      return super.all(strings, ...params);
-    }
-    get(strings, ...params) {
-      return super.get(strings, ...params);
+        });
+      default:
+        const stmt = this.formatter.compile(query);
+        if ("selection" in query) {
+          const res = (await this.values(stmt)).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 (await this.rows(stmt))[0];
+            case "rows":
+              return await this.rows(stmt);
+            default:
+              await this.execute(stmt);
+              return void 0;
+          }
+        } else {
+          return await this.mutate(stmt);
+        }
     }
-    async transaction(run) {
-      const id = `t${this.transactionId++}`;
-      const [connection, release] = this.isolate();
-      await connection.execute(
-        Query.Transaction({ op: Query.TransactionOperation.Begin, id })
+  }
+  all(strings, ...params) {
+    return super.all(strings, ...params);
+  }
+  get(strings, ...params) {
+    return super.get(strings, ...params);
+  }
+  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 })
       );
-      try {
-        const res = await run(connection);
-        await connection.execute(
-          Query.Transaction({ op: Query.TransactionOperation.Commit, id })
-        );
-        return res;
-      } catch (e) {
-        await connection.execute(
-          Query.Transaction({ op: Query.TransactionOperation.Rollback, id })
-        );
-        throw e;
-      } finally {
-        await release();
-      }
+      return res;
+    } catch (e) {
+      await connection.executeQuery(
+        Query.Transaction({ op: Query.TransactionOperation.Rollback, id })
+      );
+      throw e;
+    } finally {
+      await release();
     }
   }
-  Driver2.Async = Async;
-  class SyncWrapper extends Async {
-    constructor(sync) {
-      super();
-      this.sync = sync;
-    }
-    lock;
-    async execute(query) {
-      await this.lock;
-      return this.sync.execute(query);
-    }
-    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 SyncWrapper = class extends AsyncDriver {
+  constructor(sync) {
+    super(sync.formatter);
+    this.sync = sync;
   }
+  lock;
+  async executeQuery(query) {
+    await this.lock;
+    return super.executeQuery(query);
+  }
+  async rows(stmt) {
+    return this.sync.rows(stmt);
+  }
+  async values(stmt) {
+    return this.sync.values(stmt);
+  }
+  async execute(stmt) {
+    return this.sync.execute(stmt);
+  }
+  async mutate(stmt) {
+    return this.sync.mutate(stmt);
+  }
+  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/Formatter.d.ts

@@ -7,27 +7,32 @@ import { Statement } from './Statement';
 import { Target } from './Target';
 export interface FormatContext {
     nameResult?: string;
+    skipTableName?: boolean;
     formatAsJson?: boolean;
     formatSubject?: (subject: Statement) => Statement;
 }
 export declare abstract class Formatter implements Sanitizer {
     constructor();
     abstract escapeValue(value: any): string;
-    abstract escapeIdent(ident: string): string;
+    abstract escapeIdentifier(ident: string): string;
     abstract formatSqlAccess(on: Statement, field: string): Statement;
     abstract formatJsonAccess(on: Statement, field: string): Statement;
     formatAccess(on: Statement, field: string, formatAsJson?: boolean): Statement;
-    compile<T>(query: Query<T>, formatInline?: boolean): [string, any[]];
+    compile<T>(query: Query<T>, formatInline?: boolean): Statement.Compiled;
     format<T>(query: Query<T>, ctx?: FormatContext): Statement;
     formatSelect(query: Query.Select, ctx: FormatContext): Statement;
     formatInsert(query: Query.Insert, ctx: FormatContext): Statement;
     formatUpdate(query: Query.Update, ctx: FormatContext): Statement;
     formatDelete(query: Query.Delete, ctx: FormatContext): Statement;
     formatCreateTable(query: Query.CreateTable, ctx: FormatContext): Statement;
+    formatCreateIndex(query: Query.CreateIndex, ctx?: FormatContext): Statement;
+    formatDropIndex(query: Query.DropIndex, ctx: FormatContext): Statement;
+    formatAlterTable(query: Query.AlterTable, ctx: FormatContext): Statement;
     formatTransaction({ op, id }: Query.Transaction, ctx: FormatContext): Statement;
     formatBatch(queries: Query[], ctx: FormatContext): Statement;
     formatRaw({ strings, params }: Query.Raw, ctx: FormatContext): Statement;
     formatColumn(column: ColumnData): Statement;
+    formatContraintReference(reference: ExprData): Statement;
     formatType(type: ColumnType): Statement;
     formatInsertRow(columns: Record<string, ColumnData>, row: Record<string, any>): Statement;
     formatColumnValue(column: ColumnData, columnValue: any): Statement;
@@ -44,6 +49,7 @@ export declare abstract class Formatter implements Sanitizer {
     retrieveField(expr: ExprData, field: string): ExprData | undefined;
     formatField(expr: ExprData, field: string, ctx: FormatContext): Statement;
     formatString(input: string): Statement;
+    formatInlineValue(rawValue: any): Statement;
     formatValue(rawValue: any, formatAsJson?: boolean): Statement;
     formatExpr(expr: ExprData, ctx: FormatContext): Statement;
 }