rado 0.4.9 → 1.0.0-preview.1

package/dist/core/Emitter.js

@@ -0,0 +1,153 @@
+import {
+  getData,
+  getQuery,
+  getSelection,
+  getTable,
+  getTarget
+} from "./Internal.ts";
+import { ValueParam } from "./Param.ts";
+import { sql } from "./Sql.ts";
+class Emitter {
+  sql = "";
+  params = [];
+  bind(inputs) {
+    return this.params.map((param) => {
+      if (param instanceof ValueParam)
+        return param.value;
+      if (inputs && param.name in inputs)
+        return inputs[param.name];
+      throw new Error(`Missing input for named parameter: ${param.name}`);
+    });
+  }
+  emitUnsafe(value) {
+    this.sql += value;
+  }
+  emitField(field) {
+    this.emitIdentifier(field.targetName);
+    this.emitUnsafe(".");
+    this.emitIdentifier(field.fieldName);
+  }
+  emitCreateTable(create) {
+    const { table, ifNotExists } = getData(create);
+    const tableApi = getTable(table);
+    sql.join([
+      sql`create table`,
+      ifNotExists ? sql`if not exists` : void 0,
+      tableApi.target(),
+      sql`(${tableApi.createDefinition()})`
+    ]).emit(this);
+  }
+  emitDrop(drop) {
+    const { table, ifExists } = getData(drop);
+    const tableApi = getTable(table);
+    sql.join([
+      sql`drop table`,
+      ifExists ? sql`if exists` : void 0,
+      sql.identifier(tableApi.name)
+    ]).emit(this);
+  }
+  emitColumn(column) {
+    sql.join([
+      column.type,
+      column.primary && sql`primary key`,
+      column.notNull && sql`not null`,
+      column.isUnique && sql`unique`,
+      column.autoIncrement && sql`autoincrement`,
+      column.defaultValue && sql`default ${column.defaultValue()}`,
+      column.references && sql`references ${sql.chunk("emitReferences", [column.references()])}`,
+      column.onUpdate && sql`on update ${column.onUpdate}`
+    ]).emit(this);
+  }
+  emitReferences(fields) {
+    sql.join([
+      sql.identifier(fields[0].targetName),
+      sql`(${sql.join(
+        fields.map((field) => sql.identifier(field.fieldName)),
+        sql`, `
+      )})`
+    ]).emit(this);
+  }
+  emitDelete(deleteOp) {
+    const { cte, from, where, returning } = getData(deleteOp);
+    if (cte)
+      this.emitWith(cte);
+    const table = getTable(from);
+    sql.query({
+      deleteFrom: sql.identifier(table.name),
+      where,
+      returning
+    }).emit(this);
+  }
+  emitInsert(insert) {
+    const { cte, into, values, onConflict, returning } = getData(insert);
+    if (cte)
+      this.emitWith(cte);
+    const table = getTable(into);
+    const tableName = sql.identifier(table.name);
+    sql.query({
+      insertInto: sql`${tableName}(${table.listColumns()})`,
+      values,
+      onConflict,
+      returning
+    }).inlineFields(false).emit(this);
+  }
+  emitSelect(select) {
+    const {
+      cte,
+      from,
+      distinct,
+      distinctOn,
+      where,
+      groupBy,
+      orderBy,
+      having,
+      limit,
+      offset
+    } = getData(select);
+    if (cte)
+      this.emitWith(cte);
+    const selected = getSelection(select);
+    const prefix = distinctOn ? sql`distinct on (${sql.join(distinctOn, sql`, `)})` : distinct && sql`distinct`;
+    sql.query({
+      select: sql.join([prefix, selected]),
+      from,
+      where,
+      groupBy,
+      orderBy,
+      having,
+      limit,
+      offset
+    }).emit(this);
+  }
+  emitUnion(union) {
+    const { left, operator, right } = getData(union);
+    sql.join([getQuery(left), operator, getQuery(right)]).emit(this);
+  }
+  emitUpdate(update) {
+    const { cte, table, set, where, returning } = getData(update);
+    const tableApi = getTable(table);
+    if (cte)
+      this.emitWith(cte);
+    sql.query({
+      update: sql.identifier(tableApi.name),
+      set,
+      where,
+      returning
+    }).inlineFields(false).emit(this);
+  }
+  emitWith(cte) {
+    sql.query({
+      with: sql.join(
+        cte.map((cte2) => {
+          const query = getQuery(cte2);
+          const target = getTarget(cte2);
+          return sql`${target} as (${query})`;
+        }),
+        sql`, `
+      )
+    }).add(sql` `).emit(this);
+  }
+}
+export {
+  Emitter
+};

package/dist/core/Index.d.ts

@@ -0,0 +1,28 @@
+import { internalData, type HasData, type HasSql } from './Internal.ts';
+import type { Field, FieldData } from './expr/Field.ts';
+export interface IndexData {
+    fields: Array<FieldData>;
+    unique?: boolean;
+    concurrently?: boolean;
+    only?: boolean;
+    using?: HasSql;
+    order?: 'asc' | 'desc';
+    nulls?: 'first' | 'last';
+    where?: HasSql;
+}
+export declare class Index<TableName extends string = string> implements HasData<IndexData> {
+    private brand;
+    [internalData]: IndexData;
+    constructor(data: IndexData);
+    on<TableName extends string>(...columns: Array<Field<unknown, TableName>>): Index<TableName>;
+    concurrently(): Index<string>;
+    only(): Index<string>;
+    using<Sql>(using: HasSql<Sql>): Index<string>;
+    asc(): Index<string>;
+    desc(): Index<string>;
+    nullsFirst(): Index<string>;
+    nullsLast(): Index<string>;
+    where(where: HasSql<boolean>): Index<string>;
+}
+export declare function index(): Index<string>;
+export declare function uniqueIndex(): Index<string>;

package/dist/core/Index.js

@@ -0,0 +1,50 @@
+import {
+  getData,
+  getField,
+  internalData
+} from "./Internal.ts";
+class Index {
+  [internalData];
+  constructor(data) {
+    this[internalData] = data;
+  }
+  on(...columns) {
+    const fields = columns.map(getField);
+    return new Index({ ...getData(this), fields });
+  }
+  concurrently() {
+    return new Index({ ...getData(this), concurrently: true });
+  }
+  only() {
+    return new Index({ ...getData(this), only: true });
+  }
+  using(using) {
+    return new Index({ ...getData(this), using });
+  }
+  asc() {
+    return new Index({ ...getData(this), order: "asc" });
+  }
+  desc() {
+    return new Index({ ...getData(this), order: "desc" });
+  }
+  nullsFirst() {
+    return new Index({ ...getData(this), nulls: "first" });
+  }
+  nullsLast() {
+    return new Index({ ...getData(this), nulls: "last" });
+  }
+  where(where) {
+    return new Index({ ...getData(this), where });
+  }
+}
+function index() {
+  return new Index({ fields: [] });
+}
+function uniqueIndex() {
+  return new Index({ fields: [], unique: true });
+}
+export {
+  Index,
+  index,
+  uniqueIndex
+};

package/dist/core/Internal.d.ts

@@ -0,0 +1,67 @@
+import type { ColumnData } from './Column.ts';
+import type { QueryMeta } from './MetaData.ts';
+import type { Resolver } from './Resolver.ts';
+import type { Selection } from './Selection.ts';
+import type { Sql } from './Sql.ts';
+import type { TableApi, TableDefinition } from './Table.ts';
+import type { FieldData } from './expr/Field.ts';
+export declare const internalData: unique symbol;
+export declare const internalSql: unique symbol;
+export declare const internalSelection: unique symbol;
+export declare const internalTarget: unique symbol;
+export declare const internalQuery: unique symbol;
+export declare const internalTable: unique symbol;
+export declare const internalColumn: unique symbol;
+export declare const internalField: unique symbol;
+export declare const internalResolver: unique symbol;
+export declare const internalConstraint: unique symbol;
+export declare class HasData<Data> {
+    get [internalData](): Data;
+}
+export declare class HasSql<Value = unknown> {
+    get [internalSql](): Sql<Value>;
+}
+export declare class HasSelection {
+    get [internalSelection](): Selection;
+}
+export declare class HasTarget {
+    get [internalTarget](): Sql;
+}
+export declare class HasQuery {
+    get [internalQuery](): Sql;
+}
+export declare class HasTable<Definition extends TableDefinition = TableDefinition, Name extends string = string> {
+    get [internalTable](): TableApi<Definition, Name>;
+}
+export declare class HasColumn {
+    get [internalColumn](): ColumnData;
+}
+export declare class HasField {
+    get [internalField](): FieldData;
+}
+export declare class HasResolver<Meta extends QueryMeta = QueryMeta> {
+    get [internalResolver](): Resolver<Meta>;
+}
+export declare class HasConstraint {
+    get [internalConstraint](): Sql;
+}
+export declare const hasData: <Data>(obj: object) => obj is HasData<Data>;
+export declare const getData: <Data>(obj: HasData<Data>) => Data;
+export declare const hasSql: <Value>(obj: object) => obj is HasSql<Value>;
+export declare const getSql: <Value>(obj: HasSql<Value>) => Sql<Value>;
+export declare const hasSelection: (obj: object) => obj is HasSelection;
+export declare const getSelection: (obj: HasSelection) => Selection;
+export declare const hasTarget: (obj: object) => obj is HasTarget;
+export declare const getTarget: (obj: HasTarget) => Sql<unknown>;
+export declare const hasQuery: (obj: object) => obj is HasQuery;
+export declare const getQuery: (obj: HasQuery) => Sql<unknown>;
+export declare const hasTable: (obj: object) => obj is HasTable<TableDefinition, string>;
+export declare const getTable: (obj: HasTable) => TableApi<TableDefinition, string>;
+export declare const hasColumn: (obj: object) => obj is HasColumn;
+export declare const getColumn: (obj: HasColumn) => ColumnData;
+export declare const hasField: (obj: object) => obj is HasField;
+export declare const getField: (obj: HasField) => FieldData;
+export declare const hasResolver: <Meta extends QueryMeta>(obj: object) => obj is HasResolver<Meta>;
+export declare const getResolver: <Meta extends QueryMeta>(obj: HasResolver<Meta>) => Resolver<Meta>;
+export declare const hasConstraint: (obj: object) => obj is HasConstraint;
+export declare const getConstraint: (obj: HasConstraint) => Sql<unknown>;

package/dist/core/Internal.js

@@ -0,0 +1,62 @@
+const internalData = Symbol();
+const internalSql = Symbol();
+const internalSelection = Symbol();
+const internalTarget = Symbol();
+const internalQuery = Symbol();
+const internalTable = Symbol();
+const internalColumn = Symbol();
+const internalField = Symbol();
+const internalResolver = Symbol();
+const internalConstraint = Symbol();
+const hasData = (obj) => internalData in obj;
+const getData = (obj) => obj[internalData];
+const hasSql = (obj) => internalSql in obj;
+const getSql = (obj) => obj[internalSql];
+const hasSelection = (obj) => internalSelection in obj;
+const getSelection = (obj) => obj[internalSelection];
+const hasTarget = (obj) => internalTarget in obj;
+const getTarget = (obj) => obj[internalTarget];
+const hasQuery = (obj) => internalQuery in obj;
+const getQuery = (obj) => obj[internalQuery];
+const hasTable = (obj) => internalTable in obj;
+const getTable = (obj) => obj[internalTable];
+const hasColumn = (obj) => internalColumn in obj;
+const getColumn = (obj) => obj[internalColumn];
+const hasField = (obj) => internalField in obj;
+const getField = (obj) => obj[internalField];
+const hasResolver = (obj) => internalResolver in obj;
+const getResolver = (obj) => obj[internalResolver];
+const hasConstraint = (obj) => internalConstraint in obj;
+const getConstraint = (obj) => obj[internalConstraint];
+export {
+  getColumn,
+  getConstraint,
+  getData,
+  getField,
+  getQuery,
+  getResolver,
+  getSelection,
+  getSql,
+  getTable,
+  getTarget,
+  hasColumn,
+  hasConstraint,
+  hasData,
+  hasField,
+  hasQuery,
+  hasResolver,
+  hasSelection,
+  hasSql,
+  hasTable,
+  hasTarget,
+  internalColumn,
+  internalConstraint,
+  internalData,
+  internalField,
+  internalQuery,
+  internalResolver,
+  internalSelection,
+  internalSql,
+  internalTable,
+  internalTarget
+};

package/dist/core/MetaData.d.ts

@@ -0,0 +1,27 @@
+export type QueryMode = 'sync' | 'async' | undefined;
+export type QueryDialect = 'universal' | 'sqlite' | 'mysql' | 'postgres';
+export interface QueryMeta {
+    mode: QueryMode;
+    dialect: QueryDialect;
+}
+export interface Sync<Dialect extends QueryDialect = QueryDialect> extends QueryMeta {
+    mode: 'sync';
+    dialect: Dialect;
+}
+export interface Async<Dialect extends QueryDialect = QueryDialect> extends QueryMeta {
+    mode: 'async';
+    dialect: Dialect;
+}
+export interface IsPostgres extends QueryMeta {
+    dialect: 'postgres';
+}
+export interface IsMysql extends QueryMeta {
+    dialect: 'mysql';
+}
+export interface IsSqlite extends QueryMeta {
+    dialect: 'sqlite';
+}
+export interface Either extends QueryMeta {
+    mode: 'sync' | 'async';
+    dialect: QueryDialect;
+}

package/dist/core/Param.d.ts

@@ -0,0 +1,9 @@
+export declare class NamedParam {
+    name: string;
+    constructor(name: string);
+}
+export declare class ValueParam {
+    value: unknown;
+    constructor(value: unknown);
+}
+export type Param = NamedParam | ValueParam;

package/dist/core/Param.js

@@ -0,0 +1,14 @@
+class NamedParam {
+  constructor(name) {
+    this.name = name;
+  }
+}
+class ValueParam {
+  constructor(value) {
+    this.value = value;
+  }
+}
+export {
+  NamedParam,
+  ValueParam
+};

package/dist/core/Query.d.ts

@@ -0,0 +1,40 @@
+import { internalData, internalQuery, type HasQuery, type HasResolver, type HasTarget } from './Internal.ts';
+import type { Async, QueryMeta, Sync } from './MetaData.ts';
+import type { PreparedStatement, Resolver } from './Resolver.ts';
+import type { Sql } from './Sql.ts';
+export declare class QueryData<Meta extends QueryMeta> {
+    resolver?: Resolver<Meta>;
+    cte?: Array<HasQuery & HasTarget>;
+}
+export declare abstract class Query<Result, Meta extends QueryMeta> implements PromiseLike<Array<Result>> {
+    #private;
+    readonly [internalData]: QueryData<Meta>;
+    abstract [internalQuery]: Sql;
+    constructor(data: QueryData<Meta>);
+    [Symbol.iterator](): Generator<Promise<unknown>, Array<Result>, unknown>;
+    prepare<Inputs extends Record<string, unknown>>(name: string): PreparedQuery<Result, Inputs, Meta>;
+    all(this: Query<Result, Sync>): Array<Result>;
+    all(this: Query<Result, Async>): Promise<Array<Result>>;
+    all(db: HasResolver<Sync> | Resolver<Sync>): Array<Result>;
+    all(db: HasResolver<Async> | Resolver<Async>): Promise<Array<Result>>;
+    get(this: Query<Result, Sync>): Result;
+    get(this: Query<Result, Async>): Promise<Result>;
+    get(db: HasResolver<Sync> | Resolver<Sync>): Result;
+    get(db: HasResolver<Async> | Resolver<Async>): Promise<Result>;
+    run(this: Query<Result, Sync>): void;
+    run(this: Query<Result, Async>): Promise<void>;
+    run(db: HasResolver<Sync> | Resolver<Sync>): void;
+    run(db: HasResolver<Async> | Resolver<Async>): Promise<void>;
+    then<TResult1 = Array<Result>, TResult2 = never>(this: Query<Result, Sync | Async>, onfulfilled?: ((value: Array<Result>) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<TResult1 | TResult2>;
+    catch<TResult = never>(this: Query<Result, Async>, onrejected?: ((reason: unknown) => TResult | PromiseLike<TResult>) | undefined | null): Promise<Array<Result> | TResult>;
+    finally(this: Query<Result, Async>, onfinally?: (() => void) | undefined | null): Promise<Array<Result>>;
+}
+export interface PreparedQuery<Result, Inputs extends Record<string, unknown>, Meta extends QueryMeta> extends PreparedStatement<Meta> {
+    all(this: PreparedQuery<Result, Inputs, Sync>, inputs?: Inputs): Array<Result>;
+    all(this: PreparedQuery<Result, Inputs, Async>, inputs?: Inputs): Promise<Array<Result>>;
+    get(this: PreparedQuery<Result, Inputs, Sync>, inputs?: Inputs): Result;
+    get(this: PreparedQuery<Result, Inputs, Async>, inputs?: Inputs): Promise<Result>;
+    run(this: PreparedQuery<Result, Inputs, Sync>, inputs?: Inputs): void;
+    run(this: PreparedQuery<Result, Inputs, Async>, inputs?: Inputs): Promise<void>;
+    execute(inputs?: Inputs): Promise<Array<Result>>;
+}

package/dist/core/Query.js

@@ -0,0 +1,70 @@
+import {
+  getData,
+  getResolver,
+  hasResolver,
+  hasSelection,
+  internalData
+} from "./Internal.ts";
+class QueryData {
+  resolver;
+  cte;
+}
+class Query {
+  [internalData];
+  constructor(data) {
+    this[internalData] = data;
+  }
+  #exec(method, db) {
+    const resolver = db ? hasResolver(db) ? getResolver(db) : db : getData(this).resolver;
+    const isSelection = hasSelection(this);
+    const prepared = resolver.prepare(this, "");
+    const resultType = method ?? (isSelection ? "all" : "run");
+    try {
+      const result = prepared[resultType]();
+      if (result instanceof Promise)
+        return result.finally(prepared.free.bind(prepared));
+      prepared.free();
+      return result;
+    } catch (error) {
+      prepared.free();
+      throw error;
+    }
+  }
+  *[Symbol.iterator]() {
+    const interim = this.#exec(void 0);
+    const isAsync = interim instanceof Promise;
+    if (!isAsync)
+      return interim;
+    let result;
+    yield interim.then((v) => result = v);
+    return result;
+  }
+  prepare(name) {
+    return getData(this).resolver.prepare(this, name);
+  }
+  all(db) {
+    return this.#exec("all", db);
+  }
+  get(db) {
+    return this.#exec("get", db);
+  }
+  run(db) {
+    return this.#exec("run", db);
+  }
+  // biome-ignore lint/suspicious/noThenProperty:
+  then(onfulfilled, onrejected) {
+    const resolver = getData(this).resolver;
+    const result = this.#exec(void 0, resolver);
+    return Promise.resolve(result).then(onfulfilled, onrejected);
+  }
+  catch(onrejected) {
+    return this.#exec(void 0).catch(onrejected);
+  }
+  finally(onfinally) {
+    return this.#exec(void 0).finally(onfinally);
+  }
+}
+export {
+  Query,
+  QueryData
+};

package/dist/core/Resolver.d.ts

@@ -0,0 +1,23 @@
+import type { Dialect } from './Dialect.ts';
+import type { Driver, Statement } from './Driver.ts';
+import type { Emitter } from './Emitter.ts';
+import { type HasQuery } from './Internal.ts';
+import type { QueryMeta } from './MetaData.ts';
+export declare class Resolver<Meta extends QueryMeta = QueryMeta> {
+    #private;
+    private brand;
+    constructor(driver: Driver, dialect: Dialect);
+    prepare(query: HasQuery, name: string): PreparedStatement<Meta>;
+}
+type RowMapper = ((values: Array<unknown>) => unknown) | undefined;
+export declare class PreparedStatement<Meta extends QueryMeta> {
+    #private;
+    private brand;
+    constructor(emitter: Emitter, stmt: Statement, mapRow: RowMapper);
+    all(inputs?: Record<string, unknown>): Array<unknown> | Promise<Array<unknown>>;
+    get(inputs?: Record<string, unknown>): unknown | Promise<unknown>;
+    run(inputs?: Record<string, unknown>): unknown;
+    execute(inputs?: Record<string, unknown>): Promise<unknown>;
+    free(): void;
+}
+export {};

package/dist/core/Resolver.js

@@ -0,0 +1,54 @@
+import { getSelection, hasSelection } from "./Internal.ts";
+class Resolver {
+  #driver;
+  #dialect;
+  constructor(driver, dialect) {
+    this.#driver = driver;
+    this.#dialect = dialect;
+  }
+  prepare(query, name) {
+    const isSelection = hasSelection(query);
+    const mapRow = isSelection ? getSelection(query).mapRow : void 0;
+    const emitter = this.#dialect(query);
+    const stmt = this.#driver.prepare(emitter.sql, name);
+    return new PreparedStatement(emitter, stmt, mapRow);
+  }
+}
+class PreparedStatement {
+  #emitter;
+  #stmt;
+  #mapRow;
+  constructor(emitter, stmt, mapRow) {
+    this.#emitter = emitter;
+    this.#stmt = stmt;
+    this.#mapRow = mapRow;
+  }
+  #transform = (rows) => {
+    return this.#mapRow ? rows.map(this.#mapRow) : rows;
+  };
+  all(inputs) {
+    const rows = this.#stmt.values(this.#emitter.bind(inputs));
+    if (rows instanceof Promise)
+      return rows.then(this.#transform);
+    return this.#transform(rows);
+  }
+  get(inputs) {
+    const rows = this.all(inputs);
+    if (rows instanceof Promise)
+      return rows.then((rows2) => rows2[0]);
+    return rows[0];
+  }
+  run(inputs) {
+    return this.#stmt.run(this.#emitter.bind(inputs));
+  }
+  async execute(inputs) {
+    return this.all(inputs);
+  }
+  free() {
+    this.#stmt.free();
+  }
+}
+export {
+  PreparedStatement,
+  Resolver
+};

package/dist/core/Schema.d.ts

@@ -0,0 +1,4 @@
+import { type Table, type TableConfig, type TableDefinition } from './Table.ts';
+export declare function schema<SchemaName extends string>(schemaName: SchemaName): {
+    table<Definition extends TableDefinition, TableName extends string>(tableName: TableName, columns: Definition, config?: ((self: Table<Definition>) => TableConfig<`${SchemaName}.${TableName}`>) | undefined): Table<Definition, `${SchemaName}.${TableName}`>;
+};

package/dist/core/Schema.js

@@ -0,0 +1,13 @@
+import {
+  table
+} from "./Table.ts";
+function schema(schemaName) {
+  return {
+    table(tableName, columns, config) {
+      return table(tableName, columns, config, schemaName);
+    }
+  };
+}
+export {
+  schema
+};

package/dist/core/Selection.d.ts

@@ -0,0 +1,27 @@
+import { internalSql, type HasSql, type HasTable } from './Internal.ts';
+import { type Sql } from './Sql.ts';
+import type { Table, TableRow } from './Table.ts';
+import type { Expand } from './Types.ts';
+declare const nullable: unique symbol;
+export interface SelectionRecord extends Record<string, SelectionInput> {
+}
+export type IsNullable = {
+    [nullable]: true;
+};
+export type MakeNullable<T> = Expand<{
+    [K in keyof T]: T[K] & IsNullable;
+}>;
+export type SelectionInput = HasSql | HasTable | SelectionRecord;
+export type RowOfRecord<Input> = Expand<{
+    [Key in keyof Input as Key extends string ? Key : never]: SelectionRow<Input[Key]>;
+}>;
+export type SelectionRow<Input> = Input extends HasSql<infer Value> ? Value : Input extends IsNullable ? RowOfRecord<Input> | null : Input extends SelectionRecord ? RowOfRecord<Input> : Input extends Table<infer Definition> ? TableRow<Definition> : never;
+export declare class Selection implements HasSql {
+    #private;
+    constructor(input: SelectionInput, nullable: Set<string>);
+    makeVirtual(name: string): SelectionRecord | HasSql<unknown> | HasTable<import("./Table.ts").TableDefinition, string>;
+    mapRow: (values: Array<unknown>) => unknown;
+    get [internalSql](): Sql<unknown>;
+}
+export declare function selection(input: SelectionInput, nullable?: Set<string>): Selection;
+export {};