rado 0.4.8 → 1.0.0-preview.0

package/dist/core/query/Select.js

@@ -0,0 +1,196 @@
+import {
+  getData,
+  getQuery,
+  getSelection,
+  getTable,
+  getTarget,
+  hasTable,
+  internalData,
+  internalQuery,
+  internalSelection,
+  internalTarget
+} from "../Internal.ts";
+import { Query, QueryData } from "../Query.ts";
+import {
+  selection
+} from "../Selection.ts";
+import { sql } from "../Sql.ts";
+import { input } from "../expr/Input.ts";
+import { Union } from "./Union.ts";
+class SelectData extends QueryData {
+  select;
+  distinct;
+  distinctOn;
+  from;
+  subject;
+  where;
+  groupBy;
+  having;
+  orderBy;
+  limit;
+  offset;
+}
+class Select extends Query {
+  [internalData];
+  constructor(data) {
+    super(data);
+    this[internalData] = data;
+  }
+  as(alias) {
+    const fields = getSelection(this).makeVirtual(alias);
+    return Object.assign(fields, {
+      [internalTarget]: sql`(${getQuery(this)}) as ${sql.identifier(
+        alias
+      )}`.inlineFields(true)
+    });
+  }
+  from(target) {
+    const { select: current } = getData(this);
+    const from = getTarget(target);
+    const isTable = hasTable(target);
+    const selectionInput = current.input ?? (isTable ? target : sql`*`);
+    return new Select({
+      ...getData(this),
+      select: {
+        ...current,
+        input: selectionInput,
+        tables: isTable ? [getTable(target).aliased] : []
+      },
+      from
+    });
+  }
+  #join(operator, right, on) {
+    const { from, select: current } = getData(this);
+    const rightTable = getTable(right);
+    const addNullable = [];
+    if (operator === "right" || operator === "full")
+      addNullable.push(...current.tables);
+    if (operator === "left" || operator === "full")
+      addNullable.push(rightTable.aliased);
+    const select = current.type === "selection" ? current : {
+      type: "joinTables",
+      input: current.type === "allFrom" ? {
+        [getTable(current.input).aliased]: current.input,
+        [rightTable.aliased]: right
+      } : { ...current.input, [rightTable.aliased]: right },
+      tables: [...current.tables, rightTable.aliased],
+      nullable: current.nullable.concat(addNullable)
+    };
+    return new Select({
+      ...getData(this),
+      select,
+      from: sql.join([
+        from,
+        sql.unsafe(`${operator} join`),
+        rightTable.target(),
+        sql`on ${on}`
+      ])
+    });
+  }
+  leftJoin(right, on) {
+    return this.#join("left", right, on);
+  }
+  rightJoin(right, on) {
+    return this.#join("right", right, on);
+  }
+  innerJoin(right, on) {
+    return this.#join("inner", right, on);
+  }
+  fullJoin(right, on) {
+    return this.#join("full", right, on);
+  }
+  where(where) {
+    return new Select({ ...getData(this), where });
+  }
+  groupBy(...exprs) {
+    return new Select({
+      ...getData(this),
+      groupBy: sql.join(exprs, sql.unsafe(", "))
+    });
+  }
+  having(having) {
+    return new Select({ ...getData(this), having });
+  }
+  orderBy(...exprs) {
+    return new Select({
+      ...getData(this),
+      orderBy: sql.join(exprs, sql.unsafe(", "))
+    });
+  }
+  limit(limit) {
+    return new Select({ ...getData(this), limit: input(limit) });
+  }
+  offset(offset) {
+    return new Select({
+      ...getData(this),
+      offset: input(offset)
+    });
+  }
+  union(right) {
+    return new Union({
+      ...getData(this),
+      selection: getSelection(this),
+      left: this,
+      operator: sql`union`,
+      right
+    });
+  }
+  unionAll(right) {
+    return new Union({
+      ...getData(this),
+      selection: getSelection(this),
+      left: this,
+      operator: sql`union all`,
+      right
+    });
+  }
+  intersect(right) {
+    return new Union({
+      ...getData(this),
+      selection: getSelection(this),
+      left: this,
+      operator: sql`intersect`,
+      right
+    });
+  }
+  intersectAll(right) {
+    return new Union({
+      ...getData(this),
+      selection: getSelection(this),
+      left: this,
+      operator: sql`intersect all`,
+      right
+    });
+  }
+  except(right) {
+    return new Union({
+      ...getData(this),
+      selection: getSelection(this),
+      left: this,
+      operator: sql`except`,
+      right
+    });
+  }
+  exceptAll(right) {
+    return new Union({
+      ...getData(this),
+      selection: getSelection(this),
+      left: this,
+      operator: sql`except all`,
+      right
+    });
+  }
+  get [internalSelection]() {
+    const { select } = getData(this);
+    if (!select.input)
+      throw new Error("No selection defined");
+    return selection(select.input, new Set(select.nullable));
+  }
+  get [internalQuery]() {
+    return sql.chunk("emitSelect", this);
+  }
+}
+export {
+  Select,
+  SelectData
+};

package/dist/core/query/Union.d.ts

@@ -0,0 +1,27 @@
+import { internalData, internalQuery, internalSelection, type HasQuery, type HasSelection, type HasSql } from '../Internal.ts';
+import type { IsMysql, IsPostgres, QueryMeta } from '../MetaData.ts';
+import { Query, QueryData } from '../Query.ts';
+import type { Selection } from '../Selection.ts';
+import type { SelectBase } from './Select.ts';
+export declare class UnionData<Meta extends QueryMeta> extends QueryData<Meta> {
+    selection: Selection;
+    left: HasQuery;
+    operator: HasSql;
+    right: HasQuery;
+}
+export declare class Union<Result, Meta extends QueryMeta = QueryMeta> extends Query<Result, Meta> implements HasSelection {
+    readonly [internalData]: UnionData<Meta>;
+    readonly [internalSelection]: Selection;
+    constructor(data: UnionData<Meta>);
+    union(right: SelectBase<Result, Meta>): Union<Result, Meta>;
+    unionAll(right: SelectBase<Result, Meta>): Union<Result, Meta>;
+    intersect(right: SelectBase<Result, Meta>): Union<Result, Meta>;
+    except(right: SelectBase<Result, Meta>): Union<Result, Meta>;
+    get [internalQuery](): import("../Sql.ts").Sql<unknown>;
+}
+export declare function union<Result, Meta extends QueryMeta>(left: SelectBase<Result, Meta>, right: SelectBase<Result, Meta>): Union<Result, Meta>;
+export declare function unionAll<Result, Meta extends QueryMeta>(left: SelectBase<Result, Meta>, right: SelectBase<Result, Meta>): Union<Result, Meta>;
+export declare function intersect<Result, Meta extends QueryMeta>(left: SelectBase<Result, Meta>, right: SelectBase<Result, Meta>): Union<Result, Meta>;
+export declare function intersectAll<Result, Meta extends IsPostgres | IsMysql>(left: SelectBase<Result, Meta>, right: SelectBase<Result, Meta>): Union<Result, Meta>;
+export declare function except<Result, Meta extends QueryMeta>(left: SelectBase<Result, Meta>, right: SelectBase<Result, Meta>): Union<Result, Meta>;
+export declare function exceptAll<Result, Meta extends IsPostgres | IsMysql>(left: SelectBase<Result, Meta>, right: SelectBase<Result, Meta>): Union<Result, Meta>;

package/dist/core/query/Union.js

@@ -0,0 +1,86 @@
+import {
+  getData,
+  internalData,
+  internalQuery,
+  internalSelection
+} from "../Internal.ts";
+import { Query, QueryData } from "../Query.ts";
+import { sql } from "../Sql.ts";
+class UnionData extends QueryData {
+  selection;
+  left;
+  operator;
+  right;
+}
+class Union extends Query {
+  [internalData];
+  [internalSelection];
+  constructor(data) {
+    super(data);
+    this[internalData] = data;
+    this[internalSelection] = data.selection;
+  }
+  union(right) {
+    return new Union({
+      ...getData(this),
+      left: this,
+      operator: sql`union`,
+      right
+    });
+  }
+  unionAll(right) {
+    return new Union({
+      ...getData(this),
+      left: this,
+      operator: sql`union all`,
+      right
+    });
+  }
+  intersect(right) {
+    return new Union({
+      ...getData(this),
+      left: this,
+      operator: sql`intersect`,
+      right
+    });
+  }
+  except(right) {
+    return new Union({
+      ...getData(this),
+      left: this,
+      operator: sql`except`,
+      right
+    });
+  }
+  get [internalQuery]() {
+    return sql.chunk("emitUnion", this);
+  }
+}
+function union(left, right) {
+  return left.union(right);
+}
+function unionAll(left, right) {
+  return left.unionAll(right);
+}
+function intersect(left, right) {
+  return left.intersect(right);
+}
+function intersectAll(left, right) {
+  return left.intersectAll(right);
+}
+function except(left, right) {
+  return left.except(right);
+}
+function exceptAll(left, right) {
+  return left.exceptAll(right);
+}
+export {
+  Union,
+  UnionData,
+  except,
+  exceptAll,
+  intersect,
+  intersectAll,
+  union,
+  unionAll
+};

package/dist/core/query/Update.d.ts

@@ -0,0 +1,23 @@
+import { internalData, internalQuery, internalSelection, type HasSql, type HasTable } from '../Internal.ts';
+import type { QueryMeta } from '../MetaData.ts';
+import { Query, QueryData } from '../Query.ts';
+import { type Selection, type SelectionInput, type SelectionRow } from '../Selection.ts';
+import { type Sql } from '../Sql.ts';
+import type { TableDefinition, TableUpdate } from '../Table.ts';
+export declare class UpdateData<Meta extends QueryMeta = QueryMeta> extends QueryData<Meta> {
+    table: HasTable;
+    set?: HasSql;
+    where?: HasSql;
+    returning?: Selection;
+}
+export declare class Update<Result, Meta extends QueryMeta = QueryMeta> extends Query<Result, Meta> {
+    readonly [internalData]: UpdateData<Meta>;
+    readonly [internalSelection]?: Selection;
+    constructor(data: UpdateData<Meta>);
+    get [internalQuery](): Sql;
+}
+export declare class UpdateTable<Definition extends TableDefinition, Meta extends QueryMeta> extends Update<void, Meta> {
+    set(values: TableUpdate<Definition>): UpdateTable<Definition, Meta>;
+    where(where: HasSql<boolean>): UpdateTable<Definition, Meta>;
+    returning<Input extends SelectionInput>(returning: Input): Update<SelectionRow<Input>, Meta>;
+}

package/dist/core/query/Update.js

@@ -0,0 +1,55 @@
+import {
+  getData,
+  internalData,
+  internalQuery,
+  internalSelection
+} from "../Internal.ts";
+import { Query, QueryData } from "../Query.ts";
+import {
+  selection
+} from "../Selection.ts";
+import { sql } from "../Sql.ts";
+import { input } from "../expr/Input.ts";
+class UpdateData extends QueryData {
+  table;
+  set;
+  where;
+  returning;
+}
+class Update extends Query {
+  [internalData];
+  constructor(data) {
+    super(data);
+    this[internalData] = data;
+    if (data.returning)
+      this[internalSelection] = data.returning;
+  }
+  get [internalQuery]() {
+    return sql.chunk("emitUpdate", this);
+  }
+}
+class UpdateTable extends Update {
+  set(values) {
+    const set = sql.join(
+      Object.entries(values).map(
+        ([key, value]) => sql`${sql.identifier(key)} = ${input(value)}`
+      ),
+      sql`, `
+    );
+    return new UpdateTable({ ...getData(this), set });
+  }
+  where(where) {
+    return new UpdateTable({ ...getData(this), where });
+  }
+  returning(returning) {
+    return new Update({
+      ...getData(this),
+      returning: selection(returning)
+    });
+  }
+}
+export {
+  Update,
+  UpdateData,
+  UpdateTable
+};

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

@@ -1,16 +1,3 @@
-import type { Database } from 'better-sqlite3';
-import { SchemaInstructions } from '../define/Schema.js';
-import { Driver, DriverOptions } from '../lib/Driver.js';
-import { Statement } from '../lib/Statement.js';
-import { SqliteSchema } from '../sqlite/SqliteSchema.js';
-export declare class BetterSqlite3Driver extends Driver.Sync {
-    db: Database;
-    tableData: (tableName: string) => Array<SqliteSchema.Column>;
-    indexData: (tableName: string) => Array<SqliteSchema.Index>;
-    constructor(db: Database, options?: DriverOptions);
-    close(): void;
-    prepareStatement(stmt: Statement): Driver.Sync.PreparedStatement;
-    schemaInstructions(tableName: string): SchemaInstructions | undefined;
-    export(): Uint8Array;
-}
-export declare function connect(db: Database, options?: DriverOptions): BetterSqlite3Driver;
+import type { Database as Client } from 'better-sqlite3';
+import { SyncDatabase } from '../core/Database.ts';
+export declare function connect(db: Client): SyncDatabase<"sqlite">;

package/dist/driver/better-sqlite3.js

@@ -1,54 +1,48 @@
-import { Driver } from "../lib/Driver.js";
-import { SqliteFormatter } from "../sqlite/SqliteFormatter.js";
-import { SqliteSchema } from "../sqlite/SqliteSchema.js";
+import { SyncDatabase } from "../core/Database.ts";
+import { sqliteDialect } from "../sqlite.ts";
 class PreparedStatement {
   constructor(stmt) {
     this.stmt = stmt;
   }
-  iterate(params) {
-    return this.stmt.iterate(...params);
-  }
   all(params) {
-    return this.stmt.all(...params);
+    return this.stmt.raw(false).all(...params);
   }
   run(params) {
-    return { rowsAffected: this.stmt.run(...params).changes };
+    return this.stmt.run(...params);
   }
   get(params) {
-    return this.stmt.get(...params);
+    return this.stmt.raw(false).get(...params);
+  }
+  values(params) {
+    return this.stmt.raw(true).all(...params);
   }
-  execute(params) {
-    this.stmt.run(...params);
+  free() {
   }
 }
-class BetterSqlite3Driver extends Driver.Sync {
-  constructor(db, options) {
-    super(new SqliteFormatter(), options);
-    this.db = db;
-    this.tableData = this.prepare(SqliteSchema.tableData);
-    this.indexData = this.prepare(SqliteSchema.indexData);
-  }
-  tableData;
-  indexData;
-  close() {
-    this.db.close();
+class BetterSqlite3Driver {
+  constructor(client) {
+    this.client = client;
   }
-  prepareStatement(stmt) {
-    return new PreparedStatement(this.db.prepare(stmt.sql));
+  exec(query) {
+    this.client.exec(query);
+  }
+  close() {
+    this.client.close();
   }
-  schemaInstructions(tableName) {
-    const columnData = this.tableData(tableName);
-    const indexData = this.indexData(tableName);
-    return SqliteSchema.createInstructions(columnData, indexData);
+  prepare(sql) {
+    return new PreparedStatement(this.client.prepare(sql));
   }
-  export() {
-    return this.db.serialize();
+  transaction(run, options) {
+    let result;
+    this.client.transaction(() => {
+      result = run(this);
+    })[options.behavior ?? "deferred"]();
+    return result;
   }
 }
-function connect(db, options) {
-  return new BetterSqlite3Driver(db, options);
+function connect(db) {
+  return new SyncDatabase(new BetterSqlite3Driver(db), sqliteDialect);
 }
 export {
-  BetterSqlite3Driver,
   connect
 };

package/dist/driver/bun-sqlite.d.ts

@@ -1,19 +1,4 @@
 /// <reference types="bun-types" />
-import type { Database } from 'bun:sqlite';
-import { SchemaInstructions } from '../define/Schema.js';
-import { Driver, DriverOptions } from '../lib/Driver.js';
-import { Statement } from '../lib/Statement.js';
-import { SqliteSchema } from '../sqlite/SqliteSchema.js';
-export declare class BunSqliteDriver extends Driver.Sync {
-    db: Database;
-    tableData: (tableName: string) => Array<SqliteSchema.Column>;
-    indexData: (tableName: string) => Array<SqliteSchema.Index>;
-    lastChanges: () => {
-        rowsAffected: number;
-    };
-    constructor(db: Database, options?: DriverOptions);
-    close(): void;
-    prepareStatement(stmt: Statement): Driver.Sync.PreparedStatement;
-    schemaInstructions(tableName: string): SchemaInstructions | undefined;
-}
-export declare function connect(db: Database, options?: DriverOptions): BunSqliteDriver;
+import type { Database as Client } from 'bun:sqlite';
+import { SyncDatabase } from '../core/Database.ts';
+export declare function connect(db: Client): SyncDatabase<"sqlite">;

package/dist/driver/bun-sqlite.js

@@ -1,65 +1,49 @@
-import { QueryData, SelectFirst } from "../define/Query.js";
-import { Driver } from "../lib/Driver.js";
-import { SqliteFormatter } from "../sqlite/SqliteFormatter.js";
-import { SqliteSchema } from "../sqlite/SqliteSchema.js";
+import { SyncDatabase } from "../core/Database.ts";
+import { sqliteDialect } from "../sqlite.ts";
 class PreparedStatement {
-  constructor(lastChanges, stmt) {
-    this.lastChanges = lastChanges;
+  constructor(stmt) {
     this.stmt = stmt;
   }
-  *iterate(params) {
-    for (const row of this.stmt.all(...params))
-      yield row;
-  }
   all(params) {
     return this.stmt.all(...params);
   }
   run(params) {
-    this.stmt.run(...params);
-    return this.lastChanges();
+    return this.stmt.run(...params);
   }
   get(params) {
     return this.stmt.get(...params);
   }
-  execute(params) {
-    this.stmt.run(...params);
+  values(params) {
+    return this.stmt.values(...params);
+  }
+  free() {
+    this.stmt.finalize();
   }
 }
-class BunSqliteDriver extends Driver.Sync {
-  constructor(db, options) {
-    super(new SqliteFormatter(), options);
-    this.db = db;
-    this.tableData = this.prepare(SqliteSchema.tableData);
-    this.indexData = this.prepare(SqliteSchema.indexData);
-    this.lastChanges = this.prepare(() => {
-      return new SelectFirst(
-        new QueryData.Raw({
-          expectedReturn: "row",
-          strings: ["SELECT changes() as rowsAffected"],
-          params: []
-        })
-      );
-    });
+class BunSqliteDriver {
+  constructor(client) {
+    this.client = client;
+  }
+  exec(query) {
+    this.client.exec(query);
   }
-  tableData;
-  indexData;
-  lastChanges;
   close() {
-    this.db.close();
+    this.client.close();
   }
-  prepareStatement(stmt) {
-    return new PreparedStatement(this.lastChanges, this.db.prepare(stmt.sql));
+  prepare(sql) {
+    return new PreparedStatement(this.client.prepare(sql));
   }
-  schemaInstructions(tableName) {
-    const columnData = this.tableData(tableName);
-    const indexData = this.indexData(tableName);
-    return SqliteSchema.createInstructions(columnData, indexData);
+  transaction(run, options) {
+    let result;
+    this.client.transaction(() => {
+      result = run(this);
+    })[options.behavior ?? "deferred"]();
+    return result;
   }
 }
-function connect(db, options) {
-  return new BunSqliteDriver(db, options);
+function connect(db) {
+  return new SyncDatabase(new BunSqliteDriver(db), sqliteDialect);
 }
 export {
-  BunSqliteDriver,
   connect
 };

package/dist/driver/pg.d.ts

@@ -0,0 +1,25 @@
+import pg, { type Client, type PoolClient } from 'pg';
+import { AsyncDatabase, type TransactionOptions } from '../core/Database.ts';
+import type { AsyncDriver, AsyncStatement } from '../core/Driver.ts';
+type Queryable = Client | pg.Pool | PoolClient;
+declare class PreparedStatement implements AsyncStatement {
+    private client;
+    private sql;
+    private name?;
+    constructor(client: Queryable, sql: string, name?: string | undefined);
+    all(params: Array<unknown>): Promise<Array<object>>;
+    run(params: Array<unknown>): Promise<void>;
+    get(params: Array<unknown>): Promise<object>;
+    values(params: Array<unknown>): Promise<any[][]>;
+    free(): void;
+}
+export declare class PgDriver implements AsyncDriver {
+    private client;
+    constructor(client: Queryable);
+    exec(query: string): Promise<void>;
+    prepare(sql: string, name: string): PreparedStatement;
+    close(): Promise<void>;
+    transaction<T>(run: (inner: AsyncDriver) => Promise<T>, options: TransactionOptions['postgres'], depth: number): Promise<T>;
+}
+export declare function connect(client: Queryable): AsyncDatabase<"postgres">;
+export {};