rado 0.4.9 → 1.0.0-preview.0

package/dist/driver/pg.js

@@ -0,0 +1,81 @@
+import pg from "pg";
+import { AsyncDatabase } from "../core/Database.ts";
+import { postgresDialect } from "../postgres/PostgresDialect.ts";
+class PreparedStatement {
+  constructor(client, sql, name) {
+    this.client = client;
+    this.sql = sql;
+    this.name = name;
+  }
+  all(params) {
+    return this.client.query({
+      name: this.name,
+      text: this.sql,
+      values: params
+    }).then((res) => res.rows);
+  }
+  async run(params) {
+    await this.client.query(
+      {
+        name: this.name,
+        text: this.sql,
+        values: params
+      },
+      params
+    );
+  }
+  get(params) {
+    return this.all(params).then((rows) => rows[0] ?? null);
+  }
+  values(params) {
+    return this.client.query({
+      name: this.name,
+      text: this.sql,
+      values: params,
+      rowMode: "array"
+    }).then((res) => res.rows);
+  }
+  free() {
+  }
+}
+class PgDriver {
+  constructor(client) {
+    this.client = client;
+  }
+  async exec(query) {
+    await this.client.query(query);
+  }
+  prepare(sql, name) {
+    return new PreparedStatement(this.client, sql, name);
+  }
+  async close() {
+    if ("end" in this.client)
+      return this.client.end();
+    if ("release" in this.client)
+      return this.client.release();
+  }
+  async transaction(run, options, depth) {
+    const client = this.client instanceof pg.Pool ? await this.client.connect() : this.client;
+    try {
+      await client.query(depth > 0 ? `savepoint d${depth}` : "begin");
+      const result = await run(new PgDriver(client));
+      await client.query(depth > 0 ? `release savepoint d${depth}` : "commit");
+      return result;
+    } catch (error) {
+      await client.query(
+        depth > 0 ? `rollback to savepoint d${depth}` : "rollback"
+      );
+      throw error;
+    } finally {
+      if ("release" in client)
+        client.release();
+    }
+  }
+}
+function connect(client) {
+  return new AsyncDatabase(new PgDriver(client), postgresDialect);
+}
+export {
+  PgDriver,
+  connect
+};

package/dist/driver/pglite.d.ts

@@ -0,0 +1,24 @@
+import type { PGlite, Transaction } from '@electric-sql/pglite';
+import type { AsyncDriver, AsyncStatement } from '../core/Driver.ts';
+import { AsyncDatabase, type TransactionOptions } from '../index.ts';
+type Queryable = PGlite | Transaction;
+declare class PreparedStatement implements AsyncStatement {
+    private client;
+    private sql;
+    constructor(client: Queryable, sql: string);
+    all(params: Array<unknown>): Promise<Array<object>>;
+    run(params: Array<unknown>): Promise<void>;
+    get(params: Array<unknown>): Promise<object>;
+    values(params: Array<unknown>): Promise<unknown[][]>;
+    free(): void;
+}
+export declare class PGliteDriver implements AsyncDriver {
+    private client;
+    constructor(client: Queryable);
+    exec(query: string): Promise<void>;
+    close(): Promise<void>;
+    prepare(sql: string): PreparedStatement;
+    transaction<T>(run: (inner: AsyncDriver) => Promise<T>, options: TransactionOptions['postgres']): Promise<T>;
+}
+export declare function connect(db: PGlite): AsyncDatabase<"postgres">;
+export {};

package/dist/driver/pglite.js

@@ -0,0 +1,59 @@
+import { AsyncDatabase } from "../index.ts";
+import { postgresDialect } from "../postgres/PostgresDialect.ts";
+class PreparedStatement {
+  constructor(client, sql) {
+    this.client = client;
+    this.sql = sql;
+  }
+  all(params) {
+    return this.client.query(this.sql, params, {
+      rowMode: "object"
+    }).then((res) => res.rows);
+  }
+  async run(params) {
+    await this.client.query(this.sql, params, {
+      rowMode: "array"
+    });
+  }
+  get(params) {
+    return this.all(params).then((rows) => rows[0] ?? null);
+  }
+  values(params) {
+    return this.client.query(this.sql, params, {
+      rowMode: "array"
+    }).then((res) => res.rows);
+  }
+  free() {
+  }
+}
+class PGliteDriver {
+  constructor(client) {
+    this.client = client;
+  }
+  async exec(query) {
+    await this.client.exec(query);
+  }
+  close() {
+    if ("close" in this.client) {
+      return Promise.resolve();
+    }
+    throw new Error("Cannot close a transaction");
+  }
+  prepare(sql) {
+    return new PreparedStatement(this.client, sql);
+  }
+  async transaction(run, options) {
+    if ("transaction" in this.client)
+      return this.client.transaction((tx) => {
+        return run(new PGliteDriver(tx));
+      });
+    throw new Error("Cannot nest transactions in PGLite");
+  }
+}
+function connect(db) {
+  return new AsyncDatabase(new PGliteDriver(db), postgresDialect);
+}
+export {
+  PGliteDriver,
+  connect
+};

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

@@ -1,16 +1,3 @@
-import type { Database } from 'sql.js';
-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 SqlJsDriver 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, discardAfter: boolean): Driver.Sync.PreparedStatement;
-    schemaInstructions(tableName: string): SchemaInstructions | undefined;
-    export(): Uint8Array;
-}
-export declare function connect(db: Database, options?: DriverOptions): SqlJsDriver;
+import type { Database as Client } from 'sql.js';
+import { SyncDatabase } from '../core/Database.ts';
+export declare function connect(db: Client): SyncDatabase<import("../core/MetaData.ts").QueryDialect>;

package/dist/driver/sql.js.js

@@ -1,75 +1,69 @@
-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(db, stmt, discardAfter) {
-    this.db = db;
+  constructor(client, stmt) {
+    this.client = client;
     this.stmt = stmt;
-    this.discardAfter = discardAfter;
   }
   *iterate(params) {
     this.stmt.bind(params);
     while (this.stmt.step())
       yield this.stmt.getAsObject();
-    if (this.discardAfter)
-      this.stmt.free();
-    else
-      this.stmt.reset();
+    this.stmt.reset();
+  }
+  *iterateValues(params) {
+    this.stmt.bind(params);
+    while (this.stmt.step())
+      yield this.stmt.get();
+    this.stmt.reset();
   }
   all(params) {
     return Array.from(this.iterate(params));
   }
   run(params) {
     this.stmt.run(params);
-    if (this.discardAfter)
-      this.stmt.free();
-    else
-      this.stmt.reset();
-    return { rowsAffected: this.db.getRowsModified() };
+    this.stmt.reset();
+    return { rowsAffected: this.client.getRowsModified() };
   }
   get(params) {
-    return this.all(params)[0];
+    return this.all(params)[0] ?? null;
   }
-  execute(params) {
-    this.stmt.run(params);
-    if (this.discardAfter)
-      this.stmt.free();
-    else
-      this.stmt.reset();
+  values(params) {
+    return Array.from(this.iterateValues(params));
+  }
+  free() {
+    this.stmt.free();
   }
 }
-class SqlJsDriver extends Driver.Sync {
-  constructor(db, options) {
-    super(new SqliteFormatter(), options);
-    this.db = db;
+class SqlJsDriver {
+  constructor(client) {
+    this.client = client;
   }
-  tableData;
-  indexData;
-  close() {
-    this.db.close();
+  exec(query) {
+    this.client.exec(query);
   }
-  prepareStatement(stmt, discardAfter) {
-    return new PreparedStatement(
-      this.db,
-      this.db.prepare(stmt.sql),
-      discardAfter
-    );
+  close() {
+    this.client.close();
   }
-  schemaInstructions(tableName) {
-    this.tableData = this.tableData || (this.tableData = this.prepare(SqliteSchema.tableData));
-    this.indexData = this.indexData || (this.indexData = this.prepare(SqliteSchema.indexData));
-    const columnData = this.tableData(tableName);
-    const indexData = this.indexData(tableName);
-    return SqliteSchema.createInstructions(columnData, indexData);
+  prepare(sql) {
+    return new PreparedStatement(this.client, this.client.prepare(sql));
   }
-  export() {
-    return this.db.export();
+  transaction(run, options, depth) {
+    const behavior = options.behavior ?? "deferred";
+    this.exec(depth > 0 ? `savepoint d${depth}` : `begin ${behavior}`);
+    try {
+      const result = run(this);
+      this.exec(depth > 0 ? `release d${depth}` : "commit");
+      return result;
+    } catch (error) {
+      this.exec(depth > 0 ? `rollback to d${depth}` : "rollback");
+      throw error;
+    }
   }
 }
-function connect(db, options) {
-  return new SqlJsDriver(db, options);
+function connect(db) {
+  return new SyncDatabase(new SqlJsDriver(db), sqliteDialect);
 }
 export {
-  SqlJsDriver,
   connect
 };

package/dist/index.d.ts

@@ -1,21 +1,16 @@
-export * from './define/Column.js';
-export * from './define/Expr.js';
-export type { Fields } from './define/Fields.js';
-export * from './define/Functions.js';
-export type { Id } from './define/Id.js';
-export * from './define/Index.js';
-export * from './define/Ops.js';
-export * from './define/OrderBy.js';
-export * from './define/Param.js';
-export * from './define/Query.js';
-export * from './define/Schema.js';
-export type { Selection } from './define/Selection.js';
-export * from './define/Sql.js';
-export * from './define/Table.js';
-export * from './define/Target.js';
-export * from './define/VirtualTable.js';
-export type { Driver, DriverOptions } from './lib/Driver.js';
-export type { FormatContext, Formatter } from './lib/Formatter.js';
-export type { Sanitizer } from './lib/Sanitizer.js';
-export * from './lib/SqlError.js';
-export type { Statement } from './lib/Statement.js';
+export * from './core/Column.ts';
+export * from './core/Constraint.ts';
+export * from './core/Database.ts';
+export * from './core/Driver.ts';
+export * from './core/Index.ts';
+export * from './core/Query.ts';
+export * from './core/Selection.ts';
+export * from './core/Sql.ts';
+export * from './core/Table.ts';
+export * from './core/expr/Conditions.ts';
+export * from './core/query/CreateTable.ts';
+export * from './core/query/Delete.ts';
+export * from './core/query/Insert.ts';
+export * from './core/query/Select.ts';
+export * from './core/query/Union.ts';
+export * from './core/query/Update.ts';

package/dist/index.js

@@ -1,14 +1,16 @@
-export * from "./define/Column.js";
-export * from "./define/Expr.js";
-export * from "./define/Functions.js";
-export * from "./define/Index.js";
-export * from "./define/Ops.js";
-export * from "./define/OrderBy.js";
-export * from "./define/Param.js";
-export * from "./define/Query.js";
-export * from "./define/Schema.js";
-export * from "./define/Sql.js";
-export * from "./define/Table.js";
-export * from "./define/Target.js";
-export * from "./define/VirtualTable.js";
-export * from "./lib/SqlError.js";
+export * from "./core/Column.ts";
+export * from "./core/Constraint.ts";
+export * from "./core/Database.ts";
+export * from "./core/Driver.ts";
+export * from "./core/Index.ts";
+export * from "./core/Query.ts";
+export * from "./core/Selection.ts";
+export * from "./core/Sql.ts";
+export * from "./core/Table.ts";
+export * from "./core/expr/Conditions.ts";
+export * from "./core/query/CreateTable.ts";
+export * from "./core/query/Delete.ts";
+export * from "./core/query/Insert.ts";
+export * from "./core/query/Select.ts";
+export * from "./core/query/Union.ts";
+export * from "./core/query/Update.ts";

package/dist/migrate/Scan.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/postgres/PostgresColumns.d.ts

@@ -0,0 +1,10 @@
+import { Column, JsonColumn } from '../core/Column.ts';
+export declare function serial(name?: string): Column<number | null>;
+export declare function boolean(name?: string): Column<boolean | null>;
+export declare function integer(name?: string): Column<number | null>;
+export declare function blob(name?: string): Column<Uint8Array | null>;
+export declare function text(name?: string): Column<string | null>;
+export declare function real(name?: string): Column<number | null>;
+export declare function numeric(name?: string): Column<number | null>;
+export declare function json<T>(name?: string): JsonColumn<T | null>;
+export declare function jsonb<T>(name?: string): JsonColumn<T | null>;

package/dist/postgres/PostgresColumns.js

@@ -0,0 +1,58 @@
+import { Column, JsonColumn } from "../core/Column.ts";
+import { sql } from "../core/Sql.ts";
+function serial(name) {
+  return new Column({
+    name,
+    type: sql`serial`
+  });
+}
+function boolean(name) {
+  return new Column({
+    name,
+    type: sql`boolean`
+  });
+}
+function integer(name) {
+  return new Column({ name, type: sql`integer` });
+}
+function blob(name) {
+  return new Column({ name, type: sql`blob` });
+}
+function text(name) {
+  return new Column({ name, type: sql`text` });
+}
+function real(name) {
+  return new Column({ name, type: sql`real` });
+}
+function numeric(name) {
+  return new Column({ name, type: sql`numeric` });
+}
+function json(name) {
+  return new JsonColumn({
+    name,
+    type: sql`json`,
+    mapToDriverValue(value) {
+      return JSON.stringify(value);
+    }
+  });
+}
+function jsonb(name) {
+  return new JsonColumn({
+    name,
+    type: sql`jsonb`,
+    mapToDriverValue(value) {
+      return JSON.stringify(value);
+    }
+  });
+}
+export {
+  blob,
+  boolean,
+  integer,
+  json,
+  jsonb,
+  numeric,
+  real,
+  serial,
+  text
+};

package/dist/postgres/PostgresDialect.d.ts

@@ -0,0 +1,2 @@
+import { Emitter } from '../core/Emitter.ts';
+export declare const postgresDialect: (input: import("../core/Internal.ts").HasSql<unknown> | import("../core/Internal.ts").HasQuery) => Emitter;

package/dist/postgres/PostgresDialect.js

@@ -0,0 +1,58 @@
+import { dialect } from "../core/Dialect.ts";
+import { Emitter } from "../core/Emitter.ts";
+import { NamedParam, ValueParam } from "../core/Param.ts";
+const DOUBLE_QUOTE = '"';
+const ESCAPE_DOUBLE_QUOTE = '""';
+const MATCH_DOUBLE_QUOTE = /"/g;
+const SINGLE_QUOTE = "'";
+const ESCAPE_SINGLE_QUOTE = "''";
+const MATCH_SINGLE_QUOTE = /'/g;
+class PostgresEmitter extends Emitter {
+  paramIndex = 0;
+  emitValue(value) {
+    this.sql += `$${++this.paramIndex}`;
+    this.params.push(new ValueParam(value));
+  }
+  emitJsonPath(path) {
+    for (let i = 0; i < path.length; i++) {
+      const access = path[i];
+      if (i <= path.length - 2)
+        this.sql += "->";
+      else if (i === path.length - 1)
+        this.sql += "->>";
+      if (typeof access === "number")
+        this.sql += access;
+      else
+        this.sql += this.quoteString(access);
+    }
+  }
+  emitInline(value) {
+    if (value === null || value === void 0)
+      return this.sql += "null";
+    if (typeof value === "number" || typeof value === "boolean")
+      return this.sql += value;
+    if (typeof value === "string")
+      return this.sql += this.quoteString(value);
+    this.sql += `json(${this.quoteString(JSON.stringify(value))})`;
+  }
+  emitPlaceholder(name) {
+    this.sql += `$${++this.paramIndex}`;
+    this.params.push(new NamedParam(name));
+  }
+  quoteString(input) {
+    return SINGLE_QUOTE + input.replace(MATCH_SINGLE_QUOTE, ESCAPE_SINGLE_QUOTE) + SINGLE_QUOTE;
+  }
+  emitIdentifier(identifier) {
+    this.sql += DOUBLE_QUOTE + identifier.replace(MATCH_DOUBLE_QUOTE, ESCAPE_DOUBLE_QUOTE) + DOUBLE_QUOTE;
+  }
+  emitDefaultValue() {
+    this.sql += "default";
+  }
+  emitIdColumn() {
+    this.sql += "int generated always as identity";
+  }
+}
+const postgresDialect = dialect(PostgresEmitter);
+export {
+  postgresDialect
+};

package/dist/postgres/PostgresSchema.d.ts

@@ -0,0 +1 @@
+export { schema as pgSchema } from '../core/Schema.ts';

package/dist/postgres/PostgresSchema.js

@@ -0,0 +1,4 @@
+import { schema } from "../core/Schema.ts";
+export {
+  schema as pgSchema
+};

package/dist/postgres/PostgresTable.d.ts

@@ -0,0 +1 @@
+export { table as pgTable } from '../core/Table.ts';

package/dist/postgres/PostgresTable.js

@@ -0,0 +1,4 @@
+import { table } from "../core/Table.ts";
+export {
+  table as pgTable
+};

package/dist/postgres.d.ts

@@ -0,0 +1,2 @@
+export * from './postgres/PostgresColumns.ts';
+export * from './postgres/PostgresDialect.ts';

package/dist/postgres.js

@@ -0,0 +1,2 @@
+export * from "./postgres/PostgresColumns.ts";
+export * from "./postgres/PostgresDialect.ts";

package/dist/sqlite/SqliteColumns.d.ts

@@ -0,0 +1,9 @@
+import { Column, JsonColumn } from '../core/Column.ts';
+export declare function boolean(name?: string): Column<boolean | null>;
+export declare function integer(name?: string): Column<number | null>;
+export declare function blob(name?: string): Column<Uint8Array | null>;
+export declare function text(name?: string): Column<string | null>;
+export declare function real(name?: string): Column<number | null>;
+export declare function numeric(name?: string): Column<number | null>;
+export declare function json<T>(name?: string): JsonColumn<T | null>;
+export declare function jsonb<T>(name?: string): JsonColumn<T | null>;

package/dist/sqlite/SqliteColumns.js

@@ -0,0 +1,63 @@
+import { Column, JsonColumn } from "../core/Column.ts";
+import { sql } from "../core/Sql.ts";
+function boolean(name) {
+  return new Column({
+    name,
+    type: sql`integer`,
+    mapFromDriverValue(value) {
+      return value === 1;
+    },
+    mapToDriverValue(value) {
+      return value ? 1 : 0;
+    }
+  });
+}
+function integer(name) {
+  return new Column({ name, type: sql`integer` });
+}
+function blob(name) {
+  return new Column({ name, type: sql`blob` });
+}
+function text(name) {
+  return new Column({ name, type: sql`text` });
+}
+function real(name) {
+  return new Column({ name, type: sql`real` });
+}
+function numeric(name) {
+  return new Column({ name, type: sql`numeric` });
+}
+function json(name) {
+  return new JsonColumn({
+    name,
+    type: sql`json`,
+    mapFromDriverValue(value) {
+      return JSON.parse(value);
+    },
+    mapToDriverValue(value) {
+      return JSON.stringify(value);
+    }
+  });
+}
+function jsonb(name) {
+  return new JsonColumn({
+    name,
+    type: sql`jsonb`,
+    mapFromDriverValue(value) {
+      return JSON.parse(value);
+    },
+    mapToDriverValue(value) {
+      return JSON.stringify(value);
+    }
+  });
+}
+export {
+  blob,
+  boolean,
+  integer,
+  json,
+  jsonb,
+  numeric,
+  real,
+  text
+};

package/dist/sqlite/SqliteDialect.d.ts

@@ -0,0 +1,2 @@
+import { Emitter } from '../core/Emitter.ts';
+export declare const sqliteDialect: (input: import("../core/Internal.ts").HasSql<unknown> | import("../core/Internal.ts").HasQuery) => Emitter;

package/dist/sqlite/SqliteDialect.js

@@ -0,0 +1,51 @@
+import { dialect } from "../core/Dialect.ts";
+import { Emitter } from "../core/Emitter.ts";
+import { NamedParam, ValueParam } from "../core/Param.ts";
+const DOUBLE_QUOTE = '"';
+const ESCAPE_DOUBLE_QUOTE = '""';
+const MATCH_DOUBLE_QUOTE = /"/g;
+const SINGLE_QUOTE = "'";
+const ESCAPE_SINGLE_QUOTE = "''";
+const MATCH_SINGLE_QUOTE = /'/g;
+class SqliteEmitter extends Emitter {
+  emitValue(value) {
+    this.sql += "?";
+    this.params.push(
+      new ValueParam(typeof value === "boolean" ? value ? 1 : 0 : value)
+    );
+  }
+  emitJsonPath(path) {
+    this.sql += `->>${this.quoteString(`$.${path.join(".")}`)}`;
+  }
+  emitInline(value) {
+    if (value === null || value === void 0)
+      return this.sql += "null";
+    if (typeof value === "number")
+      return this.sql += value;
+    if (typeof value === "string")
+      return this.sql += this.quoteString(value);
+    if (typeof value === "boolean")
+      return this.sql += value ? "1" : "0";
+    this.sql += `json(${this.quoteString(JSON.stringify(value))})`;
+  }
+  emitPlaceholder(name) {
+    this.sql += "?";
+    this.params.push(new NamedParam(name));
+  }
+  emitIdentifier(identifier) {
+    this.sql += DOUBLE_QUOTE + identifier.replace(MATCH_DOUBLE_QUOTE, ESCAPE_DOUBLE_QUOTE) + DOUBLE_QUOTE;
+  }
+  emitDefaultValue() {
+    this.sql += "null";
+  }
+  quoteString(input) {
+    return SINGLE_QUOTE + input.replace(MATCH_SINGLE_QUOTE, ESCAPE_SINGLE_QUOTE) + SINGLE_QUOTE;
+  }
+  emitIdColumn() {
+    this.sql += "integer";
+  }
+}
+const sqliteDialect = dialect(SqliteEmitter);
+export {
+  sqliteDialect
+};