rado 1.0.14 → 1.2.0

package/dist/core/Emitter.js

@@ -1,14 +1,7 @@
 // src/core/Emitter.ts
-import {
-  getData,
-  getQuery,
-  getTable,
-  getTarget
-} from "./Internal.js";
+import { getSql } from "./Internal.js";
 import { ValueParam } from "./Param.js";
-import { Sql, sql } from "./Sql.js";
-import { callFunction } from "./expr/Functions.js";
-import { jsonAggregateArray, jsonArray } from "./expr/Json.js";
+import { Sql } from "./Sql.js";
 var Emitter = class {
   #runtime;
   sql = "";
@@ -32,150 +25,49 @@ var Emitter = class {
   }
   emitIdentifierOrSelf(value) {
     if (value === Sql.SELF_TARGET) {
-      if (!this.selfName) throw new Error("Self target not defined");
-      this.emitIdentifier(this.selfName);
+      if (!this.#selfName) throw new Error("Self target not defined");
+      this.emitIdentifier(this.#selfName);
     } else {
       this.emitIdentifier(value);
     }
   }
-  selfName;
-  emitSelf({ name, inner }) {
-    this.selfName = name;
-    inner.emitTo(this);
-    this.selfName = void 0;
-  }
   emitUnsafe(value) {
     this.sql += value;
   }
+  #selfName;
+  emitSelf(inner, name) {
+    this.#selfName = name;
+    inner.emit(this);
+    this.#selfName = void 0;
+  }
+  #inlineFields = false;
+  inlineFields(inner, withTableName) {
+    const previous = this.#inlineFields;
+    this.#inlineFields = !withTableName;
+    inner.emit(this);
+    this.#inlineFields = previous;
+  }
+  #inlineValues = false;
+  inlineValues(inner) {
+    const previous = this.#inlineValues;
+    this.#inlineValues = true;
+    inner.emit(this);
+    this.#inlineValues = previous;
+  }
   emitField({ targetName, fieldName }) {
+    if (this.#inlineFields) return this.emitIdentifier(fieldName);
     this.emitIdentifierOrSelf(targetName);
     this.emitUnsafe(".");
     this.emitIdentifier(fieldName);
   }
-  emitCreateTable(tableApi) {
-    sql.join([
-      sql`create table`,
-      //ifNotExists ? sql`if not exists` : undefined,
-      tableApi.target(),
-      sql`(${tableApi.createDefinition()})`
-    ]).emitTo(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}`
-    ]).emitTo(this);
-  }
-  emitReferences(fields) {
-    callFunction(
-      sql.identifier(fields[0].targetName),
-      fields.map((field) => sql.identifier(field.fieldName))
-    ).emitTo(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
-    }).emitTo(this);
-  }
-  emitInsert(insert) {
-    const {
-      cte,
-      into,
-      values,
-      select,
-      onConflict,
-      onDuplicateKeyUpdate,
-      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 ? { values } : { "": select },
-      onConflict,
-      onDuplicateKeyUpdate,
-      returning
-    }).inlineFields(false).emitTo(this);
-  }
-  emitSelect({
-    select,
-    cte,
-    from,
-    distinct,
-    distinctOn,
-    where,
-    groupBy,
-    orderBy,
-    having,
-    limit,
-    offset
-  }) {
-    if (cte) this.emitWith(cte);
-    const prefix = distinctOn ? sql`distinct on (${sql.join(distinctOn, sql`, `)})` : distinct && sql`distinct`;
-    sql.query({
-      select: sql.join([prefix, select]),
-      from,
-      where,
-      groupBy,
-      orderBy,
-      having,
-      limit,
-      offset
-    }).emitTo(this);
-  }
-  emitUnion({ left, operator, right }) {
-    sql.join([getQuery(left), operator, getQuery(right)]).emitTo(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).emitTo(this);
-  }
-  emitWith(cte) {
-    sql.query({
-      [cte.recursive ? "withRecursive" : "with"]: sql.join(
-        cte.definitions.map((cte2) => {
-          const query = getQuery(cte2);
-          const target = getTarget(cte2);
-          return sql`${target} as (${query})`;
-        }),
-        sql`, `
-      )
-    }).add(sql` `).emitTo(this);
-  }
-  emitInclude(data) {
-    const wrapQuery = Boolean(data.limit || data.offset || data.orderBy);
-    const innerQuery = sql.chunk("emitSelect", data);
-    const inner = wrapQuery ? sql`select * from (${innerQuery})` : innerQuery;
-    if (!data.select) throw new Error("No selection defined");
-    const fields = data.select.fieldNames();
-    const subject = jsonArray(
-      ...fields.map((name) => sql`_.${sql.identifier(name)}`)
-    );
-    sql`(select ${data.first ? subject : jsonAggregateArray(subject)} from (${inner}) as _)`.emitTo(this);
+  emitValueOrInline(value) {
+    if (this.#inlineValues) this.emitInline(value);
+    else this.emitValue(value);
   }
   emitUniversal(runtimes) {
-    const sql2 = runtimes[this.#runtime] ?? runtimes.default;
-    if (!sql2) throw new Error("Unsupported runtime");
-    sql2.emitTo(this);
+    const sql = runtimes[this.#runtime] ?? runtimes.default;
+    if (!sql) throw new Error("Unsupported runtime");
+    getSql(sql).emit(this);
   }
 };
 export {

package/dist/core/Index.d.ts

@@ -1,4 +1,4 @@
-import { internalData, type HasData, type HasSql } from './Internal.js';
+import { type HasData, type HasSql, internalData } from './Internal.js';
 import { type Sql } from './Sql.js';
 import type { Field } from './expr/Field.js';
 declare class IndexData {

package/dist/core/Internal.d.ts

@@ -24,16 +24,17 @@ export declare class HasSql<Value = unknown> {
 export declare class HasSelection {
     get [internalSelection](): Selection;
 }
-export declare class HasTarget {
+export declare class HasTarget<Name extends string = string> {
     get [internalTarget](): Sql;
+    private brand?;
 }
-export declare class HasQuery {
-    get [internalQuery](): Sql;
+export declare class HasQuery<Result = unknown> {
+    get [internalQuery](): Sql<Result>;
 }
 export declare class HasBatch {
     get [internalBatch](): Array<Sql>;
 }
-export declare class HasTable<Definition extends TableDefinition = TableDefinition, Name extends string = string> {
+export declare class HasTable<Definition extends TableDefinition = TableDefinition, Name extends string = string> extends HasTarget<Name> {
     get [internalTable](): TableApi<Definition, Name>;
 }
 export declare class HasField {

package/dist/core/Queries.d.ts

@@ -0,0 +1,46 @@
+import { type HasQuery, type HasResolver, type HasSql, internalData, internalQuery } from './Internal.js';
+import type { Deliver, QueryMeta } from './MetaData.js';
+import type { PreparedStatement, Resolver } from './Resolver.js';
+import type { Sql } from './Sql.js';
+export declare class QueryData<Meta extends QueryMeta> {
+    resolver?: Resolver<Meta>;
+    first?: boolean;
+}
+type Exec = Function;
+declare class Executable<Result, Meta extends QueryMeta> implements PromiseLike<Result> {
+    #private;
+    private brand;
+    constructor(exec: Exec);
+    [Symbol.iterator](): Generator<Promise<unknown>, Result, unknown>;
+    run(): Deliver<Meta, void>;
+    then<TResult1 = Result, TResult2 = never>(onfulfilled?: ((value: Result) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<TResult1 | TResult2>;
+    catch<TResult = never>(onrejected?: ((reason: unknown) => TResult | PromiseLike<TResult>) | undefined | null): Promise<Result | TResult>;
+    finally(onfinally?: (() => void) | undefined | null): Promise<Result>;
+}
+export declare class BatchQuery<Results, Meta extends QueryMeta> extends Executable<Array<Results>, Meta> {
+    constructor(queryResolver: Resolver, queries: Array<HasSql | HasQuery>);
+}
+export declare abstract class SingleQuery<Result, Meta extends QueryMeta> extends Executable<Result, Meta> {
+    #private;
+    readonly [internalData]: QueryData<Meta>;
+    abstract [internalQuery]: Sql;
+    constructor(data: QueryData<Meta>);
+    all<Result extends Array<unknown>>(this: SingleQuery<Result, Meta>, db?: HasResolver): Deliver<Meta, Result>;
+    get<Result extends Array<unknown>>(this: SingleQuery<Result, Meta>, db?: HasResolver): Deliver<Meta, Result[number] | null>;
+    get(db?: HasResolver): Deliver<Meta, Result | null>;
+    run(db?: HasResolver): Deliver<Meta, void>;
+    prepare<Inputs extends Record<string, unknown>>(name?: string): PreparedQuery<Result, Inputs, Meta>;
+    toSQL(db?: HasResolver): {
+        sql: string;
+        params: Array<unknown>;
+    };
+}
+export interface PreparedQuery<Result, Inputs extends Record<string, unknown>, Meta extends QueryMeta> extends PreparedStatement<Meta> {
+    all<Result extends Array<unknown>>(this: PreparedQuery<Result, Inputs, Meta>, inputs?: Inputs): Deliver<Meta, Result>;
+    get(inputs?: Inputs): Deliver<Meta, Result>;
+    get<Result extends Array<unknown>>(this: PreparedQuery<Result, Inputs, Meta>, inputs?: Inputs): Deliver<Meta, Result[number] | null>;
+    run(inputs?: Inputs): Deliver<Meta, void>;
+    execute(inputs?: Inputs): Promise<Result>;
+    free(): void;
+}
+export {};

package/dist/core/{Query.js → Queries.js}

@@ -1,4 +1,4 @@
-// src/core/Query.ts
+// src/core/Queries.ts
 import {
   getData,
   getResolver,
@@ -7,7 +7,7 @@ import {
 } from "./Internal.js";
 var QueryData = class {
   resolver;
-  cte;
+  first;
 };
 var Executable = class {
   #execute;
@@ -41,14 +41,14 @@ var Executable = class {
     return this.then().finally(onfinally);
   }
 };
-var QueryBatch = class extends Executable {
+var BatchQuery = class extends Executable {
   constructor(queryResolver, queries) {
     super(() => {
       return queryResolver.batch(queries).execute();
     });
   }
 };
-var Query = class extends Executable {
+var SingleQuery = class extends Executable {
   [internalData];
   constructor(data) {
     super(() => this.#exec(void 0));
@@ -57,9 +57,11 @@ var Query = class extends Executable {
   #exec(method, db) {
     const data = getData(this);
     const resolver = db ? getResolver(db) : data.resolver;
+    if (!resolver) throw new Error("Query has no resolver");
     const isSelection = hasSelection(this);
+    const isFirst = data.first;
     const prepared = resolver.prepare(this, "");
-    const resultType = method ?? (isSelection ? "all" : "run");
+    const resultType = method ?? (isSelection ? isFirst ? "get" : "all" : "run");
     try {
       const result = prepared[resultType]();
       if (result instanceof Promise)
@@ -90,7 +92,7 @@ var Query = class extends Executable {
   }
 };
 export {
-  Query,
-  QueryBatch,
-  QueryData
+  BatchQuery,
+  QueryData,
+  SingleQuery
 };

package/dist/core/Resolver.d.ts

@@ -1,5 +1,5 @@
 import type { Dialect } from './Dialect.js';
-import type { BatchQuery, Driver, DriverSpecs, Statement } from './Driver.js';
+import type { BatchedQuery, Driver, DriverSpecs, Statement } from './Driver.js';
 import type { Emitter } from './Emitter.js';
 import { type HasQuery, type HasSql } from './Internal.js';
 import type { QueryMeta } from './MetaData.js';
@@ -16,7 +16,7 @@ export declare class Resolver<Meta extends QueryMeta = QueryMeta> {
     batch(queries: Array<HasSql | HasQuery>): Batch<Meta>;
 }
 type RowMapper = ((ctx: MapRowContext) => unknown) | undefined;
-interface QueryWithMapRow extends BatchQuery {
+interface QueryWithMapRow extends BatchedQuery {
     mapRow: RowMapper;
 }
 export declare class Batch<Meta extends QueryMeta> {

package/dist/core/Selection.d.ts

@@ -1,10 +1,10 @@
 import type { DriverSpecs } from './Driver.js';
 import { type HasSql, type HasTable, type HasTarget, internalSql } from './Internal.js';
-import type { JoinOperator } from './Join.js';
 import { type Sql } from './Sql.js';
 import type { Table, TableRow } from './Table.js';
 import type { Expand } from './Types.js';
 import type { Include } from './expr/Include.js';
+import type { JoinOp } from './query/Query.js';
 declare const nullable: unique symbol;
 export interface SelectionRecord extends Record<string, SelectionInput> {
 }
@@ -14,7 +14,7 @@ export type IsNullable = {
 export type MakeNullable<T> = Expand<{
     [K in keyof T]: T[K] & IsNullable;
 }>;
-export type SelectionInput = HasSql | HasTable | SelectionRecord | Include<unknown>;
+export type SelectionInput = HasSql | HasTable | HasTarget | SelectionRecord | Include<unknown>;
 export type RowOfRecord<Input> = Expand<{
     [Key in keyof Input as Key extends string ? Key : never]: SelectionRow<Input[Key]>;
 }>;
@@ -29,24 +29,21 @@ export declare class Selection implements HasSql {
     input: SelectionInput;
     nullable: Set<string>;
     mapRow: (ctx: MapRowContext) => unknown;
-    constructor(input: SelectionInput, nullable: Set<string>);
+    constructor(input: SelectionInput, nullable?: Set<string>);
     makeVirtual<Input>(name: string): Input & HasTarget;
     fieldNames(): Array<string>;
     get [internalSql](): Sql;
-    join(right: HasTable, operator: JoinOperator): Selection;
+    join(right: HasTarget | Sql, operator: JoinOp): Selection;
 }
 export declare class TableSelection extends Selection {
     table: HasTable;
     constructor(table: HasTable);
-    join(right: HasTable, operator: JoinOperator): Selection;
+    join(right: HasTarget | Sql, operator: JoinOp): Selection;
 }
 export declare class JoinSelection extends Selection {
     tables: Array<HasTable>;
     constructor(tables: Array<HasTable>, nullable: Set<string>);
-    join(right: HasTable, operator: JoinOperator): Selection;
-}
-export declare function selection(input: SelectionInput, nullable?: Array<string>): Selection;
-export declare namespace selection {
-    function table(table: HasTable): TableSelection;
+    join(right: HasTarget | Sql, operator: JoinOp): Selection;
 }
+export declare function selection(input: SelectionInput): Selection;
 export {};

package/dist/core/Selection.js

@@ -4,6 +4,7 @@ import {
   getSql,
   getTable,
   hasField,
+  hasTable,
   internalSql
 } from "./Internal.js";
 import { sql } from "./Sql.js";
@@ -46,7 +47,7 @@ var ObjectColumn = class {
   }
 };
 var Selection = class {
-  constructor(input, nullable) {
+  constructor(input, nullable = /* @__PURE__ */ new Set()) {
     this.input = input;
     this.nullable = nullable;
     const root = this.#defineColumn(nullable, input);
@@ -91,21 +92,18 @@ var Selection = class {
         names.add(exprName);
         if (hasField(input)) {
           const field = getField(input);
-          if (field.fieldName === exprName) return expr;
+          if (field.fieldName === exprName) return [expr];
         }
-        return sql`${expr.forSelection()} as ${sql.identifier(exprName)}`;
+        return [sql`${expr.forSelection()} as ${sql.identifier(exprName)}`];
       }
-      return expr;
+      return [expr];
     }
-    return sql.join(
-      Object.entries(input).map(
-        ([name2, value]) => this.#selectionToSql(value, names, name2)
-      ),
-      sql`, `
+    return Object.entries(input).flatMap(
+      ([name2, value]) => this.#selectionToSql(value, names, name2)
     );
   }
   get [internalSql]() {
-    return this.#selectionToSql(this.input, /* @__PURE__ */ new Set());
+    return sql.join(this.#selectionToSql(this.input, /* @__PURE__ */ new Set()), sql`, `);
   }
   join(right, operator) {
     return this;
@@ -118,11 +116,12 @@ var TableSelection = class extends Selection {
   }
   join(right, operator) {
     const leftTable = getTable(this.table);
+    if (!hasTable(right)) return this;
     const rightTable = getTable(right);
     const nullable = new Set(this.nullable);
-    if (operator === "right" || operator === "full")
+    if (operator === "rightJoin" || operator === "fullJoin")
       nullable.add(leftTable.aliased);
-    if (operator === "left" || operator === "full")
+    if (operator === "leftJoin" || operator === "fullJoin")
       nullable.add(rightTable.aliased);
     return new JoinSelection([this.table, right], nullable);
   }
@@ -136,24 +135,24 @@ var JoinSelection = class _JoinSelection extends Selection {
     this.tables = tables;
   }
   join(right, operator) {
+    if (!hasTable(right)) return this;
     const rightTable = getTable(right);
     const nullable = new Set(this.nullable);
-    if (operator === "right" || operator === "full")
+    if (operator === "rightJoin" || operator === "fullJoin")
       this.tables.map((table) => getTable(table).aliased).forEach(nullable.add, nullable);
-    if (operator === "left" || operator === "full")
+    if (operator === "leftJoin" || operator === "fullJoin")
       nullable.add(rightTable.aliased);
     return new _JoinSelection([...this.tables, right], nullable);
   }
 };
-function selection(input, nullable = []) {
-  return new Selection(input, new Set(nullable));
+var selected = /* @__PURE__ */ new WeakMap();
+function selection(input) {
+  if (input instanceof Selection) return input;
+  if (selected.has(input)) return selected.get(input);
+  const selection2 = hasTable(input) ? new TableSelection(input) : new Selection(input);
+  selected.set(input, selection2);
+  return selection2;
 }
-((selection2) => {
-  function table(table2) {
-    return new TableSelection(table2);
-  }
-  selection2.table = table;
-})(selection || (selection = {}));
 export {
   JoinSelection,
   Selection,

package/dist/core/Sql.d.ts

@@ -4,42 +4,23 @@ import { type HasSql, internalSql } from './Internal.js';
 import type { Runtime } from './MetaData.js';
 import type { FieldData } from './expr/Field.js';
 import type { JsonPath } from './expr/Json.js';
-type EmitMethods = {
-    [K in keyof Emitter as K extends `emit${string}` ? K : never]: Emitter[K];
-};
-declare class Chunk<Type = keyof EmitMethods, Inner = unknown> {
-    type: Type;
-    inner: Inner;
-    constructor(type: Type, inner: Inner);
-}
-export type Decoder<T> = ((value: unknown) => T) | {
+export type Decoder<T = unknown> = ((value: unknown) => T) | {
     mapFromDriverValue?(value: unknown, specs: DriverSpecs): T;
 };
 export declare class Sql<Value = unknown> implements HasSql<Value> {
-    #private;
+    emit: (emitter: Emitter) => void;
     static SELF_TARGET: string;
     private brand;
     alias?: string;
     mapFromDriverValue?: (input: unknown, specs: DriverSpecs) => Value;
     readonly [internalSql]: this;
-    constructor(chunks?: Array<Chunk>);
+    constructor(emit?: (emitter: Emitter) => void);
     as(name: string): Sql<Value>;
     mapWith<T = Value>(decoder: Decoder<T>): Sql<T>;
-    chunk<Type extends keyof EmitMethods>(type: Type, inner: Parameters<EmitMethods[Type]>[0]): Sql<Value>;
-    unsafe(sql: string): Sql<Value>;
-    field(field: FieldData): Sql<Value>;
-    add(sql: HasSql): Sql<Value>;
-    value(value: unknown): Sql<Value>;
-    getValue(): Value | undefined;
-    inline(value: unknown): Sql<Value>;
-    jsonPath(path: JsonPath): Sql<Value>;
-    forSelection(): Sql<Value>;
-    placeholder(name: string): Sql<Value>;
-    identifier(identifier: string): Sql<Value>;
-    inlineValues(): Sql<Value>;
     inlineFields(withTableName: boolean): Sql<Value>;
-    nameSelf(name: string): Sql;
-    emitTo(emitter: Emitter): void;
+    inlineValues(): Sql<Value>;
+    nameSelf(name: string): Sql<Value>;
+    forSelection(): Sql<Value>;
 }
 export declare function sql<T>(strings: TemplateStringsArray, ...inner: Array<HasSql | unknown>): Sql<T>;
 export declare namespace sql {
@@ -51,11 +32,9 @@ export declare namespace sql {
     export function identifier<T>(identifier: string): Sql<T>;
     export function field<T>(field: FieldData): Sql<T>;
     export function jsonPath<T>(path: JsonPath): Sql<T>;
-    export function chunk<Type extends keyof EmitMethods>(type: Type, inner: Parameters<EmitMethods[Type]>[0]): Sql;
-    export function universal<T>(runtimes: Partial<Record<Runtime | 'default', Sql<T>>>): Sql<T>;
+    export function universal<T>(runtimes: Partial<Record<Runtime | 'default', HasSql<T>>>): Sql<T>;
     type QueryChunk = HasSql | undefined;
-    export function query(ast: Record<string, boolean | QueryChunk | Array<QueryChunk>>): Sql;
+    export function query(...chunks: Array<QueryChunk | Record<string, boolean | QueryChunk | Array<QueryChunk>>>): Sql;
     export function join<T>(items: Array<Sql | HasSql | undefined | false>, separator?: Sql): Sql<T>;
     export {};
 }
-export {};