rado 0.4.8 → 1.0.0-preview.0

package/dist/core/Builder.d.ts

@@ -0,0 +1,36 @@
+import { internalData, type HasQuery, type HasSql, type HasTable, type HasTarget } from './Internal.ts';
+import type { IsPostgres, QueryMeta } from './MetaData.ts';
+import type { QueryData } from './Query.ts';
+import type { SelectionInput } from './Selection.ts';
+import type { Table, TableDefinition } from './Table.ts';
+import { Create } from './query/CreateTable.ts';
+import { DeleteFrom } from './query/Delete.ts';
+import { Drop } from './query/DropTable.ts';
+import { InsertInto } from './query/Insert.ts';
+import type { SelectBase, WithSelection, WithoutSelection } from './query/Select.ts';
+import { UpdateTable } from './query/Update.ts';
+declare class BuilderBase<Meta extends QueryMeta> {
+    readonly [internalData]: QueryData<Meta>;
+    constructor(data: QueryData<Meta>);
+    createTable<Definition extends TableDefinition>(table: Table<Definition>): Create<Meta>;
+    dropTable(table: HasTable): Drop<Meta>;
+    select(): WithoutSelection<Meta>;
+    select<Input extends SelectionInput>(selection: Input): WithSelection<Input, Meta>;
+    selectDistinct(): WithoutSelection<Meta>;
+    selectDistinct<Input extends SelectionInput>(selection: Input): WithSelection<Input, Meta>;
+    selectDistinctOn(this: Builder<IsPostgres>, columns: Array<HasSql>): WithoutSelection<Meta>;
+    selectDistinctOn<Input extends SelectionInput>(this: Builder<IsPostgres>, columns: Array<HasSql>, selection: Input): WithSelection<Input, Meta>;
+    update<Definition extends TableDefinition>(table: Table<Definition>): UpdateTable<Definition, Meta>;
+    insert<Definition extends TableDefinition>(into: Table<Definition>): InsertInto<Definition, Meta>;
+    delete(from: HasTable): DeleteFrom<Meta>;
+}
+export type CTE<Input = unknown> = Input & HasTarget & HasQuery;
+export declare class Builder<Meta extends QueryMeta> extends BuilderBase<Meta> {
+    $with(cteName: string): {
+        as<Input extends SelectionInput>(query: SelectBase<Input, Meta>): CTE<Input>;
+    };
+    with(...cte: Array<CTE>): BuilderBase<Meta>;
+    createTable<Definition extends TableDefinition>(table: Table<Definition>): Create<Meta>;
+    dropTable(table: HasTable): Drop<Meta>;
+}
+export {};

package/dist/core/Builder.js

@@ -0,0 +1,99 @@
+import {
+  getData,
+  getQuery,
+  getSelection,
+  internalData,
+  internalQuery,
+  internalTarget
+} from "./Internal.ts";
+import { sql } from "./Sql.ts";
+import { Create } from "./query/CreateTable.ts";
+import { DeleteFrom } from "./query/Delete.ts";
+import { Drop } from "./query/DropTable.ts";
+import { InsertInto } from "./query/Insert.ts";
+import { Select } from "./query/Select.ts";
+import { UpdateTable } from "./query/Update.ts";
+class BuilderBase {
+  [internalData];
+  constructor(data) {
+    this[internalData] = data;
+  }
+  createTable(table) {
+    return new Create({ ...getData(this), table });
+  }
+  dropTable(table) {
+    return new Drop({ ...getData(this), table });
+  }
+  select(input) {
+    return new Select({
+      ...getData(this),
+      select: {
+        type: input ? "selection" : "allFrom",
+        input,
+        tables: [],
+        nullable: []
+      }
+    });
+  }
+  selectDistinct(input) {
+    return new Select({
+      ...getData(this),
+      select: {
+        type: input ? "selection" : "allFrom",
+        input,
+        tables: [],
+        nullable: []
+      },
+      distinct: true
+    });
+  }
+  selectDistinctOn(columns, selection) {
+    return new Select({
+      ...getData(this),
+      select: {
+        type: selection ? "selection" : "allFrom",
+        input: selection,
+        tables: [],
+        nullable: []
+      },
+      distinctOn: columns
+    });
+  }
+  update(table) {
+    return new UpdateTable({ ...getData(this), table });
+  }
+  insert(into) {
+    return new InsertInto({ ...getData(this), into });
+  }
+  delete(from) {
+    return new DeleteFrom({ ...getData(this), from });
+  }
+}
+class Builder extends BuilderBase {
+  $with(cteName) {
+    return {
+      as(query) {
+        const fields = getSelection(query).makeVirtual(cteName);
+        return Object.assign(fields, {
+          [internalTarget]: sql.identifier(cteName),
+          [internalQuery]: getQuery(query)
+        });
+      }
+    };
+  }
+  with(...cte) {
+    return new BuilderBase({
+      ...getData(this),
+      cte
+    });
+  }
+  createTable(table) {
+    return new Create({ ...getData(this), table });
+  }
+  dropTable(table) {
+    return new Drop({ ...getData(this), table });
+  }
+}
+export {
+  Builder
+};

package/dist/core/Column.d.ts

@@ -0,0 +1,38 @@
+import type { HasColumn, HasSql } from './Internal.ts';
+import { internalColumn } from './Internal.ts';
+import type { Sql } from './Sql.ts';
+import type { Field, FieldData } from './expr/Field.ts';
+import { type Input } from './expr/Input.ts';
+export declare class ColumnData {
+    type: Sql;
+    name?: string;
+    json?: boolean;
+    primary?: boolean;
+    notNull?: boolean;
+    isUnique?: boolean;
+    autoIncrement?: boolean;
+    defaultValue?(): HasSql;
+    references?(): FieldData;
+    onUpdate?: HasSql;
+    onDelete?: HasSql;
+    mapFromDriverValue?(value: unknown): unknown;
+    mapToDriverValue?(value: unknown): unknown;
+}
+export declare class Column<Value = unknown> implements HasColumn {
+    readonly [internalColumn]: ColumnData;
+    constructor(data: ColumnData);
+    notNull(): RequiredColumn<NonNullable<Value>>;
+    default(value: Input<NonNullable<Value>> | (() => Input<NonNullable<Value>>)): Column<NonNullable<Value>>;
+    primaryKey(): Column<NonNullable<Value>>;
+    unique(name?: string): Column<Value>;
+    references(foreignField: Field | (() => Field)): Column<Value>;
+}
+export declare class JsonColumn<Value = unknown> extends Column<Value> {
+    private brand;
+    constructor(data: ColumnData);
+}
+declare const required: unique symbol;
+export interface RequiredColumn<Value = unknown> extends Column<Value> {
+    [required]: true;
+}
+export {};

package/dist/core/Column.js

@@ -0,0 +1,59 @@
+import { getField, internalColumn } from "./Internal.ts";
+import { input } from "./expr/Input.ts";
+class ColumnData {
+  type;
+  name;
+  json;
+  primary;
+  notNull;
+  isUnique;
+  autoIncrement;
+  onUpdate;
+  onDelete;
+}
+class Column {
+  [internalColumn];
+  constructor(data) {
+    this[internalColumn] = data;
+  }
+  notNull() {
+    return new Column({
+      ...this[internalColumn],
+      notNull: true
+    });
+  }
+  default(value) {
+    return new Column({
+      ...this[internalColumn],
+      defaultValue() {
+        return input(value instanceof Function ? value() : value);
+      }
+    });
+  }
+  primaryKey() {
+    return new Column({ ...this[internalColumn], primary: true });
+  }
+  unique(name) {
+    return new Column({ ...this[internalColumn], isUnique: true });
+  }
+  references(foreignField) {
+    return new Column({
+      ...this[internalColumn],
+      references() {
+        return getField(
+          typeof foreignField === "function" ? foreignField() : foreignField
+        );
+      }
+    });
+  }
+}
+class JsonColumn extends Column {
+  constructor(data) {
+    super({ ...data, json: true });
+  }
+}
+export {
+  Column,
+  ColumnData,
+  JsonColumn
+};

package/dist/core/Constraint.d.ts

@@ -0,0 +1,39 @@
+import { internalConstraint, internalData, type HasConstraint, type HasData } from './Internal.ts';
+import type { Field, FieldData } from './expr/Field.ts';
+export interface UniqueConstraintData {
+    fields: Array<FieldData>;
+    nullsNotDistinct?: boolean;
+}
+export declare class UniqueConstraint<TableName extends string = string> implements HasData<UniqueConstraintData>, HasConstraint {
+    private brand;
+    [internalData]: UniqueConstraintData;
+    constructor(data: UniqueConstraintData);
+    on<TableName extends string>(...columns: Array<Field<unknown, TableName>>): UniqueConstraint<TableName>;
+    nullsNotDistinct(): UniqueConstraint<string>;
+    get [internalConstraint](): import("./Sql.ts").Sql<unknown>;
+}
+export declare function unique(): UniqueConstraint<string>;
+export interface PrimaryKeyConstraintData {
+    fields: Array<FieldData>;
+}
+export declare class PrimaryKeyConstraint<TableName extends string = string> implements HasData<PrimaryKeyConstraintData>, HasConstraint {
+    data: PrimaryKeyConstraintData;
+    private brand;
+    [internalData]: PrimaryKeyConstraintData;
+    constructor(data: PrimaryKeyConstraintData);
+    get [internalConstraint](): import("./Sql.ts").Sql<unknown>;
+}
+export declare function primaryKey<TableName extends string = string>(...fields: Array<Field<unknown, TableName>>): PrimaryKeyConstraint<TableName>;
+export interface ForeignKeyConstraintData {
+    fields: Array<FieldData>;
+    references: Array<FieldData>;
+}
+export declare class ForeignKeyConstraint<TableName extends string = string> implements HasData<ForeignKeyConstraintData>, HasConstraint {
+    private brand;
+    [internalData]: ForeignKeyConstraintData;
+    constructor(data: ForeignKeyConstraintData);
+    references<ForeignTable extends string>(...fields: Array<Field<unknown, ForeignTable>>): ForeignKeyConstraint<TableName>;
+    get [internalConstraint](): import("./Sql.ts").Sql<unknown>;
+}
+export declare function foreignKey<TableName extends string = string>(...fields: Array<Field<unknown, TableName>>): ForeignKeyConstraint<TableName>;
+export type Constraint = UniqueConstraint | PrimaryKeyConstraint | ForeignKeyConstraint;

package/dist/core/Constraint.js

@@ -0,0 +1,87 @@
+import {
+  getData,
+  getField,
+  internalConstraint,
+  internalData
+} from "./Internal.ts";
+import { sql } from "./Sql.ts";
+class UniqueConstraint {
+  [internalData];
+  constructor(data) {
+    this[internalData] = data;
+  }
+  on(...columns) {
+    const fields = columns.map(getField);
+    return new UniqueConstraint({ ...getData(this), fields });
+  }
+  nullsNotDistinct() {
+    return new UniqueConstraint({ ...getData(this), nullsNotDistinct: true });
+  }
+  get [internalConstraint]() {
+    const { fields, nullsNotDistinct } = getData(this);
+    return sql.join([
+      sql`unique`,
+      nullsNotDistinct ? sql`nulls not distinct` : void 0,
+      sql`(${sql.join(
+        fields.map((field) => sql.identifier(field.fieldName)),
+        sql`, `
+      )})`
+    ]);
+  }
+}
+function unique() {
+  return new UniqueConstraint({ fields: [] });
+}
+class PrimaryKeyConstraint {
+  constructor(data) {
+    this.data = data;
+    this[internalData] = data;
+  }
+  [internalData];
+  get [internalConstraint]() {
+    const { fields } = getData(this);
+    return sql`primary key (${sql.join(
+      fields.map((field) => sql.identifier(field.fieldName)),
+      sql`, `
+    )})`;
+  }
+}
+function primaryKey(...fields) {
+  return new PrimaryKeyConstraint({ fields: fields.map(getField) });
+}
+class ForeignKeyConstraint {
+  [internalData];
+  constructor(data) {
+    this[internalData] = data;
+  }
+  references(...fields) {
+    return new ForeignKeyConstraint({
+      ...getData(this),
+      references: fields.map(getField)
+    });
+  }
+  get [internalConstraint]() {
+    const { fields, references } = getData(this);
+    return sql`foreign key (${sql.join(
+      fields.map((field) => sql.identifier(field.fieldName)),
+      sql`, `
+    )}) references ${sql.identifier(references[0].targetName)} (${sql.join(
+      references.map((field) => sql.identifier(field.fieldName)),
+      sql`, `
+    )})`;
+  }
+}
+function foreignKey(...fields) {
+  return new ForeignKeyConstraint({
+    fields: fields.map(getField),
+    references: []
+  });
+}
+export {
+  ForeignKeyConstraint,
+  PrimaryKeyConstraint,
+  UniqueConstraint,
+  foreignKey,
+  primaryKey,
+  unique
+};

package/dist/core/Database.d.ts

@@ -0,0 +1,43 @@
+import { Builder } from './Builder.ts';
+import type { Dialect } from './Dialect.ts';
+import type { Driver } from './Driver.ts';
+import { internalResolver, type HasResolver } from './Internal.ts';
+import type { Async, Either, QueryDialect, QueryMeta, Sync } from './MetaData.ts';
+import { Resolver } from './Resolver.ts';
+export declare class Database<Meta extends QueryMeta = Either> extends Builder<Meta> implements HasResolver<Meta> {
+    #private;
+    readonly [internalResolver]: Resolver<Meta>;
+    constructor(driver: Driver, dialect: Dialect, transactionDepth?: number);
+    close(this: Database<Async>): Promise<void>;
+    close(this: Database<Sync>): void;
+    [Symbol.dispose](this: Database<Sync>): void;
+    [Symbol.asyncDispose](this: Database<Async>): Promise<void>;
+    transaction<T>(this: Database<Sync>, run: (tx: Transaction<Meta>) => T, options?: TransactionOptions[Meta['dialect']]): T;
+    transaction<T>(this: Database<Async>, run: (tx: Transaction<Meta>) => Promise<T>, options?: TransactionOptions[Meta['dialect']]): Promise<T>;
+    transaction<T>(run: (tx: Transaction<Meta>) => T | Promise<T>, options?: TransactionOptions[Meta['dialect']]): T | Promise<T>;
+}
+export interface TransactionOptions {
+    universal: never;
+    sqlite: {
+        behavior?: 'deferred' | 'immediate' | 'exclusive';
+    };
+    postgres: {
+        isolationLevel?: 'read uncommitted' | 'read committed' | 'repeatable read' | 'serializable';
+        accessMode?: 'read only' | 'read write';
+        deferrable?: boolean;
+    };
+    mysql: {
+        isolationLevel?: 'read uncommitted' | 'read committed' | 'repeatable read' | 'serializable';
+        accessMode?: 'read only' | 'read write';
+        withConsistentSnapshot?: boolean;
+    };
+}
+export declare class Rollback extends Error {
+}
+export declare class Transaction<Meta extends QueryMeta> extends Database<Meta> {
+    rollback(): never;
+}
+export declare class SyncDatabase<Dialect extends QueryDialect> extends Database<Sync<Dialect>> {
+}
+export declare class AsyncDatabase<Dialect extends QueryDialect> extends Database<Async<Dialect>> {
+}

package/dist/core/Database.js

@@ -0,0 +1,58 @@
+import { Builder } from "./Builder.ts";
+import { internalResolver } from "./Internal.ts";
+import { Resolver } from "./Resolver.ts";
+class Database extends Builder {
+  [internalResolver];
+  #driver;
+  #dialect;
+  #transactionDepth;
+  constructor(driver, dialect, transactionDepth = 0) {
+    const resolver = new Resolver(driver, dialect);
+    super({ resolver });
+    this[internalResolver] = resolver;
+    this.#driver = driver;
+    this.#dialect = dialect;
+    this.#transactionDepth = transactionDepth;
+  }
+  close() {
+    return this.#driver.close();
+  }
+  [Symbol.dispose]() {
+    this.close();
+  }
+  async [Symbol.asyncDispose]() {
+    return this.close();
+  }
+  transaction(run, options = {}) {
+    return this.#driver.transaction(
+      (inner) => {
+        const tx = new Transaction(
+          inner,
+          this.#dialect,
+          this.#transactionDepth + 1
+        );
+        return run(tx);
+      },
+      options,
+      this.#transactionDepth
+    );
+  }
+}
+class Rollback extends Error {
+}
+class Transaction extends Database {
+  rollback() {
+    throw new Rollback("Rollback");
+  }
+}
+class SyncDatabase extends Database {
+}
+class AsyncDatabase extends Database {
+}
+export {
+  AsyncDatabase,
+  Database,
+  Rollback,
+  SyncDatabase,
+  Transaction
+};

package/dist/core/Dialect.d.ts

@@ -0,0 +1,6 @@
+import type { Emitter } from './Emitter.ts';
+import { type HasQuery, type HasSql } from './Internal.ts';
+export declare function dialect(createEmitter: {
+    new (): Emitter;
+}): (input: HasSql | HasQuery) => Emitter;
+export type Dialect = ReturnType<typeof dialect>;

package/dist/core/Dialect.js

@@ -0,0 +1,16 @@
+import {
+  getQuery,
+  getSql,
+  hasSql
+} from "./Internal.ts";
+function dialect(createEmitter) {
+  return (input) => {
+    const sql = hasSql(input) ? getSql(input) : getQuery(input);
+    const emitter = new createEmitter();
+    sql.emit(emitter);
+    return emitter;
+  };
+}
+export {
+  dialect
+};

package/dist/core/Driver.d.ts

@@ -0,0 +1,28 @@
+export type Driver = SyncDriver | AsyncDriver;
+export type Statement = SyncStatement | AsyncStatement;
+export interface SyncDriver {
+    close(): void;
+    exec(query: string): void;
+    prepare(query: string, name?: string): SyncStatement;
+    transaction<T>(run: (inner: SyncDriver) => T, options: unknown, depth: number): T;
+}
+export interface SyncStatement {
+    all(params: Array<unknown>): Array<object>;
+    run(params: Array<unknown>): void;
+    get(params: Array<unknown>): object | null;
+    values(params: Array<unknown>): Array<Array<unknown>>;
+    free(): void;
+}
+export interface AsyncDriver {
+    close(): Promise<void>;
+    exec(query: string): Promise<void>;
+    prepare(query: string, name?: string): AsyncStatement;
+    transaction<T>(run: (inner: AsyncDriver) => Promise<T>, options: unknown, depth: number): Promise<T>;
+}
+export interface AsyncStatement {
+    all(params: Array<unknown>): Promise<Array<object>>;
+    run(params: Array<unknown>): Promise<void>;
+    get(params: Array<unknown>): Promise<object | null>;
+    values(params: Array<unknown>): Promise<Array<Array<unknown>>>;
+    free(): void;
+}

package/dist/core/Emitter.d.ts

@@ -0,0 +1,35 @@
+import type { ColumnData } from './Column.ts';
+import { type HasQuery, type HasTarget } from './Internal.ts';
+import { type Param } from './Param.ts';
+import type { FieldData } from './expr/Field.ts';
+import type { Create } from './query/CreateTable.ts';
+import type { Delete } from './query/Delete.ts';
+import type { Drop } from './query/DropTable.ts';
+import type { Insert } from './query/Insert.ts';
+import type { Select } from './query/Select.ts';
+import type { Union } from './query/Union.ts';
+import type { Update } from './query/Update.ts';
+export declare abstract class Emitter {
+    sql: string;
+    params: Array<Param>;
+    bind(inputs?: Record<string, unknown>): Array<unknown>;
+    abstract emitIdentifier(value: string): void;
+    abstract emitValue(value: unknown): void;
+    abstract emitInline(value: unknown): void;
+    abstract emitJsonPath(value: Array<number | string>): void;
+    abstract emitPlaceholder(value: string): void;
+    abstract emitDefaultValue(): void;
+    emitUnsafe(value: string): void;
+    emitField(field: FieldData): void;
+    emitCreateTable(create: Create): void;
+    emitDrop(drop: Drop): void;
+    emitColumn(column: ColumnData): void;
+    emitReferences(fields: Array<FieldData>): void;
+    emitDelete(deleteOp: Delete<unknown>): void;
+    emitInsert(insert: Insert<unknown>): void;
+    emitSelect(select: Select<unknown>): void;
+    emitUnion(union: Union<unknown>): void;
+    emitUpdate(update: Update<unknown>): void;
+    abstract emitIdColumn(): void;
+    emitWith(cte: Array<HasQuery & HasTarget>): void;
+}