rado 1.0.2 → 1.0.4

package/dist/core/Builder.d.ts

@@ -5,7 +5,8 @@ import { type SelectionInput } from './Selection.js';
 import type { Table, TableDefinition } from './Table.js';
 import { DeleteFrom } from './query/Delete.js';
 import { InsertInto } from './query/Insert.js';
-import type { SelectBase, WithSelection, WithoutSelection } from './query/Select.js';
+import type { WithSelection, WithoutSelection } from './query/Select.js';
+import type { UnionBase } from './query/Union.js';
 import { UpdateTable } from './query/Update.js';
 declare class BuilderBase<Meta extends QueryMeta> {
     readonly [internalData]: QueryData<Meta>;
@@ -23,8 +24,9 @@ declare class BuilderBase<Meta extends QueryMeta> {
 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>;
+        as<Input extends SelectionInput>(query: UnionBase<Input, Meta>): CTE<Input>;
     };
-    with(...cte: Array<CTE>): BuilderBase<Meta>;
+    with(...definitions: Array<CTE>): BuilderBase<Meta>;
+    withRecursive(...definitions: Array<CTE>): BuilderBase<Meta>;
 }
 export {};

package/dist/core/Builder.js

@@ -4,11 +4,9 @@ import {
   getQuery,
   getSelection,
   internalData,
-  internalQuery,
-  internalTarget
+  internalQuery
 } from "./Internal.js";
 import { selection } from "./Selection.js";
-import { sql } from "./Sql.js";
 import { DeleteFrom } from "./query/Delete.js";
 import { InsertInto } from "./query/Insert.js";
 import { Select } from "./query/Select.js";
@@ -21,32 +19,20 @@ var BuilderBase = class {
   select(input) {
     return new Select({
       ...getData(this),
-      select: {
-        type: input ? "selection" : "allFrom",
-        selection: input && selection(input),
-        tables: []
-      }
+      select: input && selection(input)
     });
   }
   selectDistinct(input) {
     return new Select({
       ...getData(this),
-      select: {
-        type: input ? "selection" : "allFrom",
-        selection: input && selection(input),
-        tables: []
-      },
+      select: input && selection(input),
       distinct: true
     });
   }
   selectDistinctOn(columns, input) {
     return new Select({
       ...getData(this),
-      select: {
-        type: input ? "selection" : "allFrom",
-        selection: input && selection(input),
-        tables: []
-      },
+      select: input && selection(input),
       distinctOn: columns
     });
   }
@@ -66,16 +52,21 @@ var Builder = class extends BuilderBase {
       as(query) {
         const fields = getSelection(query).makeVirtual(cteName);
         return Object.assign(fields, {
-          [internalTarget]: sql.identifier(cteName),
-          [internalQuery]: getQuery(query)
+          [internalQuery]: getQuery(query).nameSelf(cteName)
         });
       }
     };
   }
-  with(...cte) {
+  with(...definitions) {
+    return new BuilderBase({
+      ...getData(this),
+      cte: { recursive: false, definitions }
+    });
+  }
+  withRecursive(...definitions) {
     return new BuilderBase({
       ...getData(this),
-      cte
+      cte: { recursive: true, definitions }
     });
   }
 };

package/dist/core/Emitter.d.ts

@@ -2,14 +2,14 @@ import type { ColumnData } from './Column.js';
 import { type HasQuery, type HasTarget } from './Internal.js';
 import type { Runtime } from './MetaData.js';
 import { type Param } from './Param.js';
-import { type Sql } from './Sql.js';
+import { Sql } from './Sql.js';
 import type { TableApi } from './Table.js';
 import type { FieldData } from './expr/Field.js';
 import type { IncludeData } from './expr/Include.js';
 import type { Delete } from './query/Delete.js';
 import type { Insert } from './query/Insert.js';
 import type { SelectData } from './query/Select.js';
-import type { Union } from './query/Union.js';
+import type { UnionData } from './query/Union.js';
 import type { Update } from './query/Update.js';
 export declare abstract class Emitter {
     sql: string;
@@ -23,17 +23,26 @@ export declare abstract class Emitter {
     abstract emitInline(value: unknown): void;
     abstract emitJsonPath(value: Array<number | string>): void;
     abstract emitPlaceholder(value: string): void;
+    emitIdentifierOrSelf(value: string): void;
+    selfName?: string;
+    emitSelf({ name, inner }: {
+        name: string;
+        inner: Sql;
+    }): void;
     emitUnsafe(value: string): void;
-    emitField(field: FieldData): void;
+    emitField({ targetName, fieldName }: FieldData): void;
     emitCreateTable(tableApi: TableApi): void;
     emitColumn(column: ColumnData): void;
     emitReferences(fields: Array<FieldData>): void;
     emitDelete(deleteOp: Delete<unknown>): void;
     emitInsert(insert: Insert<unknown>): void;
     emitSelect({ select, cte, from, distinct, distinctOn, where, groupBy, orderBy, having, limit, offset }: SelectData): void;
-    emitUnion(union: Union<unknown>): void;
+    emitUnion({ left, operator, right }: UnionData): void;
     emitUpdate(update: Update<unknown>): void;
-    emitWith(cte: Array<HasQuery & HasTarget>): void;
+    emitWith(cte: {
+        recursive: boolean;
+        definitions: Array<HasQuery & HasTarget>;
+    }): void;
     emitInclude(data: IncludeData): void;
     emitUniversal(runtimes: Partial<Record<Runtime | 'default', Sql>>): void;
 }

package/dist/core/Emitter.js

@@ -6,7 +6,7 @@ import {
   getTarget
 } from "./Internal.js";
 import { ValueParam } from "./Param.js";
-import { sql } from "./Sql.js";
+import { Sql, sql } from "./Sql.js";
 import { callFunction } from "./expr/Functions.js";
 import { jsonAggregateArray, jsonArray } from "./expr/Json.js";
 var Emitter = class {
@@ -27,13 +27,28 @@ var Emitter = class {
   processValue(value) {
     return value;
   }
+  emitIdentifierOrSelf(value) {
+    if (value === Sql.SELF_TARGET) {
+      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;
   }
-  emitField(field) {
-    this.emitIdentifier(field.targetName);
+  emitField({ targetName, fieldName }) {
+    this.emitIdentifierOrSelf(targetName);
     this.emitUnsafe(".");
-    this.emitIdentifier(field.fieldName);
+    this.emitIdentifier(fieldName);
   }
   emitCreateTable(tableApi) {
     sql.join([
@@ -102,7 +117,7 @@ var Emitter = class {
       this.emitWith(cte);
     const prefix = distinctOn ? sql`distinct on (${sql.join(distinctOn, sql`, `)})` : distinct && sql`distinct`;
     sql.query({
-      select: sql.join([prefix, select.selection]),
+      select: sql.join([prefix, select]),
       from,
       where,
       groupBy,
@@ -112,8 +127,7 @@ var Emitter = class {
       offset
     }).emitTo(this);
   }
-  emitUnion(union) {
-    const { left, operator, right } = getData(union);
+  emitUnion({ left, operator, right }) {
     sql.join([getQuery(left), operator, getQuery(right)]).emitTo(this);
   }
   emitUpdate(update) {
@@ -130,8 +144,8 @@ var Emitter = class {
   }
   emitWith(cte) {
     sql.query({
-      with: sql.join(
-        cte.map((cte2) => {
+      [cte.recursive ? "withRecursive" : "with"]: sql.join(
+        cte.definitions.map((cte2) => {
           const query = getQuery(cte2);
           const target = getTarget(cte2);
           return sql`${target} as (${query})`;
@@ -144,9 +158,9 @@ var Emitter = class {
     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.selection)
+    if (!data.select)
       throw new Error("No selection defined");
-    const fields = data.select.selection.fieldNames();
+    const fields = data.select.fieldNames();
     const subject = jsonArray(
       ...fields.map((name) => sql`_.${sql.identifier(name)}`)
     );

package/dist/core/Join.d.ts

@@ -0,0 +1 @@
+export type JoinOperator = 'left' | 'right' | 'inner' | 'full';

package/dist/core/Query.d.ts

@@ -1,10 +1,13 @@
-import { internalData, internalQuery, type HasQuery, type HasResolver, type HasSql, type HasTarget } from './Internal.js';
+import { type HasQuery, type HasResolver, type HasSql, type HasTarget, 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>;
-    cte?: Array<HasQuery & HasTarget>;
+    cte?: {
+        recursive: boolean;
+        definitions: Array<HasQuery & HasTarget>;
+    };
 }
 type Exec = () => any;
 declare class Executable<Result, Meta extends QueryMeta> implements PromiseLike<Array<Result>> {

package/dist/core/Selection.d.ts

@@ -1,5 +1,6 @@
 import type { DriverSpecs } from './Driver.js';
-import { internalSql, type HasSql, type HasTable } from './Internal.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';
@@ -29,9 +30,23 @@ export declare class Selection implements HasSql {
     nullable: Set<string>;
     mapRow: (ctx: MapRowContext) => unknown;
     constructor(input: SelectionInput, nullable: Set<string>);
-    makeVirtual(name: string): SelectionInput;
-    get [internalSql](): Sql;
+    makeVirtual<Input>(name: string): Input & HasTarget;
     fieldNames(): Array<string>;
+    get [internalSql](): Sql;
+    join(right: HasTable, operator: JoinOperator): Selection;
+}
+export declare class TableSelection extends Selection {
+    table: HasTable;
+    constructor(table: HasTable);
+    join(right: HasTable, operator: JoinOperator): 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;
+}
 export {};

package/dist/core/Selection.js

@@ -2,6 +2,7 @@
 import {
   getField,
   getSql,
+  getTable,
   hasField,
   internalSql
 } from "./Internal.js";
@@ -69,9 +70,6 @@ var Selection = class {
       ])
     );
   }
-  get [internalSql]() {
-    return this.#selectionToSql(this.input, /* @__PURE__ */ new Set());
-  }
   fieldNames() {
     return this.#fieldNames(this.input, /* @__PURE__ */ new Set());
   }
@@ -111,11 +109,59 @@ var Selection = class {
       sql`, `
     );
   }
+  get [internalSql]() {
+    return this.#selectionToSql(this.input, /* @__PURE__ */ new Set());
+  }
+  join(right, operator) {
+    return this;
+  }
+};
+var TableSelection = class extends Selection {
+  constructor(table) {
+    super(table, /* @__PURE__ */ new Set());
+    this.table = table;
+  }
+  join(right, operator) {
+    const leftTable = getTable(this.table);
+    const rightTable = getTable(right);
+    const nullable = new Set(this.nullable);
+    if (operator === "right" || operator === "full")
+      nullable.add(leftTable.aliased);
+    if (operator === "left" || operator === "full")
+      nullable.add(rightTable.aliased);
+    return new JoinSelection([this.table, right], nullable);
+  }
+};
+var JoinSelection = class _JoinSelection extends Selection {
+  constructor(tables, nullable) {
+    super(
+      Object.fromEntries(tables.map((table) => [getTable(table).aliased, table])),
+      nullable
+    );
+    this.tables = tables;
+  }
+  join(right, operator) {
+    const rightTable = getTable(right);
+    const nullable = new Set(this.nullable);
+    if (operator === "right" || operator === "full")
+      this.tables.map((table) => getTable(table).aliased).forEach(nullable.add, nullable);
+    if (operator === "left" || operator === "full")
+      nullable.add(rightTable.aliased);
+    return new _JoinSelection([...this.tables, right], nullable);
+  }
 };
 function selection(input, nullable = []) {
   return new Selection(input, new Set(nullable));
 }
+((selection2) => {
+  function table(table2) {
+    return new TableSelection(table2);
+  }
+  selection2.table = table;
+})(selection || (selection = {}));
 export {
+  JoinSelection,
   Selection,
+  TableSelection,
   selection
 };

package/dist/core/Sql.d.ts

@@ -16,6 +16,7 @@ export type Decoder<T> = ((value: unknown) => T) | {
 };
 export declare class Sql<Value = unknown> implements HasSql<Value> {
     #private;
+    static SELF_TARGET: string;
     private brand;
     alias?: string;
     mapFromDriverValue?: (input: unknown, specs: DriverSpecs) => Value;
@@ -34,6 +35,7 @@ export declare class Sql<Value = unknown> implements HasSql<Value> {
     identifier(identifier: string): Sql<Value>;
     inlineValues(): Sql<Value>;
     inlineFields(withTableName: boolean): Sql<Value>;
+    nameSelf(name: string): Sql;
     emitTo(emitter: Emitter): void;
 }
 export declare function sql<T>(strings: TemplateStringsArray, ...inner: Array<HasSql>): Sql<T>;

package/dist/core/Sql.js

@@ -7,6 +7,7 @@ var Chunk = class {
   }
 };
 var Sql = class _Sql {
+  static SELF_TARGET = "$$self";
   alias;
   mapFromDriverValue;
   [internalSql] = this;
@@ -60,7 +61,7 @@ var Sql = class _Sql {
     return this.chunk("emitPlaceholder", name);
   }
   identifier(identifier) {
-    return this.chunk("emitIdentifier", identifier);
+    return this.chunk("emitIdentifierOrSelf", identifier);
   }
   inlineValues() {
     return new _Sql(
@@ -79,7 +80,7 @@ var Sql = class _Sql {
         const data = chunk.inner;
         if (withTableName)
           return [
-            new Chunk("emitIdentifier", data.targetName),
+            new Chunk("emitIdentifierOrSelf", data.targetName),
             new Chunk("emitUnsafe", "."),
             new Chunk("emitIdentifier", data.fieldName)
           ];
@@ -87,6 +88,9 @@ var Sql = class _Sql {
       })
     );
   }
+  nameSelf(name) {
+    return sql.chunk("emitSelf", { name, inner: this });
+  }
   emitTo(emitter) {
     for (const chunk of this.#chunks)
       emitter[chunk.type](chunk.inner);

package/dist/core/Virtual.d.ts

@@ -1,2 +1,2 @@
-import type { SelectionInput } from './Selection.js';
-export declare function virtual<Input extends SelectionInput>(alias: string, source?: Input): Input;
+import { type HasTarget } from './Internal.js';
+export declare function virtual<Input>(alias: string, source?: Input): Input & HasTarget;

package/dist/core/Virtual.js

@@ -1,22 +1,24 @@
 // src/core/Virtual.ts
-import { getSql, hasSql } from "./Internal.js";
+import { getSql, hasSql, internalTarget } from "./Internal.js";
+import { sql } from "./Sql.js";
 import { Field } from "./expr/Field.js";
 function virtual(alias, source) {
+  const target = { [internalTarget]: sql.identifier(alias) };
   if (source && hasSql(source)) {
     const expr = getSql(source);
     const name = expr.alias;
     if (!name)
       throw new Error("Cannot alias a virtual field without a name");
-    return new Field(alias, name, expr);
+    return Object.assign(new Field(alias, name, expr), target);
   }
-  return new Proxy(/* @__PURE__ */ Object.create(null), {
-    get(target, field) {
-      if (field in target)
-        return target[field];
+  return new Proxy(target, {
+    get(target2, field) {
+      if (field in target2)
+        return target2[field];
       const from = source?.[field];
       if (typeof field !== "string")
         return from;
-      return target[field] = new Field(
+      return target2[field] = new Field(
         alias,
         field,
         from ? getSql(from) : void 0

package/dist/core/expr/Conditions.d.ts

@@ -1,6 +1,7 @@
 import { type HasSql } from '../Internal.js';
+import type { Either } from '../MetaData.js';
+import type { Query } from '../Query.js';
 import { type Sql } from '../Sql.js';
-import type { Select } from '../query/Select.js';
 import { type Input } from './Input.js';
 export declare const eq: <T>(left: Input<T>, right: Input<T>) => Sql<boolean>;
 export declare const ne: <T>(left: Input<T>, right: Input<T>) => Sql<boolean>;
@@ -18,8 +19,8 @@ export declare const arrayOverlaps: <T>(left: Input<Array<T>>, right: Input<Arra
 export declare function and(...conditions: Array<undefined | Input<boolean>>): Sql<boolean>;
 export declare function or(...conditions: Array<undefined | Input<boolean>>): Sql<boolean>;
 export declare function not(condition: Input<boolean>): Sql<boolean>;
-export declare function inArray<T>(left: Input<T>, right: Input<Array<T>>): Sql<boolean>;
-export declare function notInArray<T>(left: Input<T>, right: Input<Array<T>>): Sql<boolean>;
+export declare function inArray<T>(left: Input<T>, right: Query<T, any> | Input<Array<T>>): Sql<boolean>;
+export declare function notInArray<T>(left: Input<T>, right: Query<T, any> | Input<Array<T>>): Sql<boolean>;
 export declare function isNull(value: Input): Sql<boolean>;
 export declare function isNotNull(value: Input): Sql<boolean>;
 export declare function between<T>(value: Input<T>, left: Input<T>, right: Input<T>): Sql<boolean>;
@@ -29,4 +30,4 @@ export declare function desc<T>(input: HasSql<T>): Sql;
 export declare function distinct<T>(input: HasSql<T>): Sql;
 export declare function when<In, Out>(compare: Input<In>, ...cases: Array<[condition: Input<In>, result: Input<Out>] | Input<Out>>): Sql<Out>;
 export declare function when<Out>(...cases: Array<[condition: Input<boolean>, result: Input<Out>] | Input<Out>>): Sql<Out>;
-export declare function exists<T>(query: Select<T>): Sql<boolean>;
+export declare function exists(query: Query<any, Either>): Sql<boolean>;

package/dist/core/expr/Conditions.js

@@ -2,8 +2,11 @@
 import { getQuery } from "../Internal.js";
 import { sql } from "../Sql.js";
 import { input } from "./Input.js";
+function bool(impl) {
+  return impl.mapWith(Boolean);
+}
 function binop(operator) {
-  return (left, right) => sql`${input(left)} ${sql.unsafe(operator)} ${input(right)}`;
+  return (left, right) => bool(sql`${input(left)} ${sql.unsafe(operator)} ${input(right)}`);
 }
 var eq = binop("=");
 var ne = binop("<>");
@@ -21,49 +24,53 @@ var arrayOverlaps = binop("&&");
 function and(...conditions) {
   const inputs = conditions.filter((v) => v !== void 0).map(input);
   if (inputs.length === 0)
-    return sql`true`;
+    return bool(sql`true`);
   if (inputs.length === 1)
-    return inputs[0];
-  return sql`(${sql.join(inputs, sql` and `)})`;
+    return bool(inputs[0]);
+  return bool(sql`(${sql.join(inputs, sql` and `)})`);
 }
 function or(...conditions) {
   const inputs = conditions.filter((v) => v !== void 0).map(input);
   if (inputs.length === 0)
-    return sql`true`;
+    return bool(sql`true`);
   if (inputs.length === 1)
-    return inputs[0];
-  return sql`(${sql.join(inputs, sql` or `)})`;
+    return bool(inputs[0]);
+  return bool(sql`(${sql.join(inputs, sql` or `)})`);
 }
 function not(condition) {
-  return sql`not ${input(condition)}`;
+  return bool(sql`not ${input(condition)}`);
 }
 function inArray(left, right) {
   if (Array.isArray(right)) {
     if (right.length === 0)
       return sql`false`;
-    return sql`${input(left)} in (${sql.join(right.map(input), sql`, `)})`;
+    return bool(sql`${input(left)} in (${sql.join(right.map(input), sql`, `)})`);
   }
-  return sql`${input(left)} in ${input(right)}`;
+  return bool(sql`${input(left)} in ${input(right)}`);
 }
 function notInArray(left, right) {
   if (Array.isArray(right)) {
     if (right.length === 0)
       return sql`true`;
-    return sql`${input(left)} not in (${sql.join(right.map(input), sql`, `)})`;
+    return bool(
+      sql`${input(left)} not in (${sql.join(right.map(input), sql`, `)})`
+    );
   }
-  return sql`${input(left)} not in ${input(right)}`;
+  return bool(sql`${input(left)} not in ${input(right)}`);
 }
 function isNull(value) {
-  return sql`${input(value)} is null`;
+  return bool(sql`${input(value)} is null`);
 }
 function isNotNull(value) {
-  return sql`${input(value)} is not null`;
+  return bool(sql`${input(value)} is not null`);
 }
 function between(value, left, right) {
-  return sql`${input(value)} between ${input(left)} and ${input(right)}`;
+  return bool(sql`${input(value)} between ${input(left)} and ${input(right)}`);
 }
 function notBetween(value, left, right) {
-  return sql`${input(value)} not between ${input(left)} and ${input(right)}`;
+  return bool(
+    sql`${input(value)} not between ${input(left)} and ${input(right)}`
+  );
 }
 function asc(input2) {
   return sql`${input2} asc`;
@@ -94,7 +101,7 @@ function when(...cases) {
   ]);
 }
 function exists(query) {
-  return sql`exists (${getQuery(query)})`;
+  return bool(sql`exists (${getQuery(query)})`);
 }
 export {
   and,

package/dist/core/expr/Include.d.ts

@@ -1,4 +1,4 @@
-import { internalData, internalSql, type HasData, type HasSql } from '../Internal.js';
+import { type HasData, type HasSql, internalData, internalSql } from '../Internal.js';
 import type { QueryMeta } from '../MetaData.js';
 import type { RowOfRecord } from '../Selection.js';
 import { type Sql } from '../Sql.js';

package/dist/core/expr/Include.js

@@ -12,10 +12,9 @@ var Include = class {
   }
   #mapFromDriverValue = (value, specs) => {
     const { select, first } = getData(this);
-    const selection = select.selection;
     const parsed = specs.parsesJson ? value : JSON.parse(value);
     if (first)
-      return parsed ? selection.mapRow({ values: parsed, index: 0, specs }) : null;
+      return parsed ? select.mapRow({ values: parsed, index: 0, specs }) : null;
     if (!parsed)
       return [];
     const rows = parsed;
@@ -27,7 +26,7 @@ var Include = class {
     for (let i = 0; i < rows.length; i++) {
       ctx.values = rows[i];
       ctx.index = 0;
-      rows[i] = selection.mapRow(ctx);
+      rows[i] = select.mapRow(ctx);
     }
     return rows ?? [];
   };

package/dist/core/query/Delete.js

@@ -31,7 +31,7 @@ var DeleteFrom = class _DeleteFrom extends Delete {
     const data = getData(this);
     return new Delete({
       ...data,
-      returning: selection(returning ?? data.from)
+      returning: returning ? selection(returning) : selection.table(data.from)
     });
   }
 };

package/dist/core/query/Insert.js

@@ -30,7 +30,7 @@ var InsertCanReturn = class extends Insert {
     const data = getData(this);
     return new Insert({
       ...data,
-      returning: selection(returning ?? data.into)
+      returning: returning ? selection(returning) : selection.table(data.into)
     });
   }
 };

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

@@ -1,6 +1,5 @@
-import { internalData, internalQuery, internalSelection, internalSql, type HasSelection, type HasSql, type HasTable, type HasTarget } from '../Internal.js';
+import { type HasSelection, type HasSql, type HasTable, type HasTarget, internalData, internalQuery, internalSelection, internalSql } from '../Internal.js';
 import type { QueryMeta } from '../MetaData.js';
-import type { Query } from '../Query.js';
 import { type IsNullable, type MakeNullable, type Selection, type SelectionRecord, type SelectionRow } from '../Selection.js';
 import { type Sql } from '../Sql.js';
 import type { Table, TableDefinition, TableFields } from '../Table.js';
@@ -10,11 +9,6 @@ import { type Input as UserInput } from '../expr/Input.js';
 import { UnionBase, type UnionBaseData } from './Union.js';
 export type SelectionType = 'selection' | 'allFrom' | 'joinTables';
 export interface SelectData<Meta extends QueryMeta = QueryMeta> extends UnionBaseData<Meta> {
-    select: {
-        type: SelectionType;
-        tables: Array<string>;
-        selection?: Selection;
-    };
     distinct?: boolean;
     distinctOn?: Array<HasSql>;
     from?: HasSql;
@@ -31,13 +25,13 @@ export declare class Select<Input, Meta extends QueryMeta = QueryMeta> extends U
     constructor(data: SelectData<Meta>);
     as(alias: string): SubQuery<Input>;
     from(target: HasTarget | HasSql): Select<Input, Meta>;
-    leftJoin(right: HasTable, on: HasSql<boolean>): Select<Input, Meta>;
-    rightJoin(right: HasTable, on: HasSql<boolean>): Select<Input, Meta>;
-    innerJoin(right: HasTable, on: HasSql<boolean>): Select<Input, Meta>;
-    fullJoin(right: HasTable, on: HasSql<boolean>): Select<Input, Meta>;
+    leftJoin(right: HasTable | HasTarget, on: HasSql<boolean>): Select<Input, Meta>;
+    rightJoin(right: HasTable | HasTarget, on: HasSql<boolean>): Select<Input, Meta>;
+    innerJoin(right: HasTable | HasTarget, on: HasSql<boolean>): Select<Input, Meta>;
+    fullJoin(right: HasTable | HasTarget, on: HasSql<boolean>): Select<Input, Meta>;
     where(...where: Array<HasSql<boolean> | undefined>): Select<Input, Meta>;
     groupBy(...exprs: Array<HasSql>): Select<Input, Meta>;
-    having(having: HasSql<boolean>): Select<Input, Meta>;
+    having(having: HasSql<boolean> | ((self: Input) => HasSql<boolean>)): Select<Input, Meta>;
     orderBy(...exprs: Array<HasSql>): Select<Input, Meta>;
     limit(limit: UserInput<number>): Select<Input, Meta>;
     offset(offset: UserInput<number>): Select<Input, Meta>;
@@ -59,7 +53,7 @@ export interface WithoutSelection<Meta extends QueryMeta> {
     from<Definition extends TableDefinition, Name extends string>(from: Table<Definition, Name>): AllFrom<TableFields<Definition>, Meta, Record<Name, TableFields<Definition>>>;
     from<Input>(from: SubQuery<Input>): SelectionFrom<Input, Meta>;
 }
-export interface WithSelection<Input, Meta extends QueryMeta> extends Query<SelectionRow<Input>, Meta>, HasSql<SelectionRow<Input>> {
+export interface WithSelection<Input, Meta extends QueryMeta> extends SelectBase<Input, Meta>, HasSql<SelectionRow<Input>> {
     from<Definition extends TableDefinition, Name extends string>(from: Table<Definition, Name>): SelectionFrom<Input, Meta>;
     from(from: SubQuery<unknown>): SelectionFrom<Input, Meta>;
     from(target: HasSql): Select<Input, Meta>;
@@ -75,8 +69,12 @@ type MarkFieldsAsNullable<Input, TableName extends string> = Expand<{
 }>;
 export interface SelectionFrom<Input, Meta extends QueryMeta> extends SelectBase<Input, Meta> {
     leftJoin<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>, on: HasSql<boolean>): SelectionFrom<MarkFieldsAsNullable<Input, Name>, Meta>;
+    leftJoin(right: HasTarget, on: HasSql<boolean>): SelectionFrom<Input, Meta>;
     rightJoin<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>, on: HasSql<boolean>): SelectionFrom<Input, Meta>;
+    rightJoin(right: HasTarget, on: HasSql<boolean>): SelectionFrom<Input, Meta>;
     innerJoin<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>, on: HasSql<boolean>): SelectionFrom<Input, Meta>;
+    innerJoin(right: HasTarget, on: HasSql<boolean>): SelectionFrom<Input, Meta>;
     fullJoin<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>, on: HasSql<boolean>): SelectionFrom<Input, Meta>;
+    fullJoin(right: HasTarget, on: HasSql<boolean>): SelectionFrom<Input, Meta>;
 }
 export {};

package/dist/core/query/Select.js

@@ -4,7 +4,6 @@ import {
   getQuery,
   getSelection,
   getSql,
-  getTable,
   getTarget,
   hasTable,
   hasTarget,
@@ -37,50 +36,24 @@ var Select = class _Select extends UnionBase {
   }
   from(target) {
     const { select: current } = getData(this);
-    const selected = current.selection;
     const from = hasTarget(target) ? getTarget(target) : getSql(target);
     const isTable = hasTable(target);
-    const selectionInput = selected ?? selection(isTable ? target : sql`*`);
+    const selected = current ?? (isTable ? selection.table(target) : selection(sql`*`));
     return new _Select({
       ...getData(this),
-      select: {
-        ...current,
-        selection: selectionInput,
-        tables: isTable ? [getTable(target).aliased] : []
-      },
+      select: selected,
       from
     });
   }
   #join(operator, right, on) {
     const { from, select: current } = getData(this);
-    const selected = current.selection;
-    const rightTable = getTable(right);
-    const addNullable = [];
-    if (operator === "right" || operator === "full")
-      addNullable.push(...current.tables);
-    if (operator === "left" || operator === "full")
-      addNullable.push(rightTable.aliased);
-    if (selected)
-      addNullable.push(...selected.nullable);
-    const select = current.type === "selection" ? current : {
-      type: "joinTables",
-      selection: selection(current.type === "allFrom" ? {
-        // Todo: handle this properly
-        [getTable(selected.input).aliased]: selected.input,
-        [rightTable.aliased]: right
-      } : {
-        ...selected?.input,
-        [rightTable.aliased]: right
-      }, addNullable),
-      tables: [...current.tables, rightTable.aliased]
-    };
     return new _Select({
       ...getData(this),
-      select,
+      select: hasTable(right) ? current?.join(right, operator) : current,
       from: sql.join([
         from,
         sql.unsafe(`${operator} join`),
-        rightTable.target(),
+        getTarget(right),
         sql`on ${on}`
       ])
     });
@@ -107,7 +80,10 @@ var Select = class _Select extends UnionBase {
     });
   }
   having(having) {
-    return new _Select({ ...getData(this), having });
+    return new _Select({
+      ...getData(this),
+      having: typeof having === "function" ? having(getSelection(this).input) : having
+    });
   }
   orderBy(...exprs) {
     return new _Select({
@@ -126,9 +102,9 @@ var Select = class _Select extends UnionBase {
   }
   get [internalSelection]() {
     const { select } = getData(this);
-    if (!select.selection)
+    if (!select)
       throw new Error("No selection defined");
-    return select.selection;
+    return select;
   }
   get [internalQuery]() {
     return sql.chunk("emitSelect", getData(this));

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

@@ -1,21 +1,22 @@
-import { internalData, internalQuery, internalSelection, type HasQuery, type HasSelection, type HasSql } from '../Internal.js';
+import { type HasQuery, type HasSelection, type HasSql, type HasTarget, internalData, internalQuery, internalSelection } from '../Internal.js';
 import type { IsMysql, IsPostgres, QueryMeta } from '../MetaData.js';
 import { Query, type QueryData } from '../Query.js';
 import type { Selection, SelectionRow } from '../Selection.js';
-import { type Sql } from '../Sql.js';
+import { Sql } from '../Sql.js';
 export interface UnionBaseData<Meta extends QueryMeta> extends QueryData<Meta> {
-    selection?: Selection;
+    select?: Selection;
 }
 export declare abstract class UnionBase<Input, Meta extends QueryMeta = QueryMeta> extends Query<SelectionRow<Input>, Meta> {
+    #private;
     readonly [internalData]: UnionBaseData<Meta>;
-    union(right: UnionBase<Input, Meta>): Union<Input, Meta>;
-    unionAll(right: UnionBase<Input, Meta>): Union<Input, Meta>;
-    intersect(right: UnionBase<Input, Meta>): Union<Input, Meta>;
-    intersectAll(this: UnionBase<Input, IsPostgres | IsMysql>, right: UnionBase<Input, Meta>): Union<Input, Meta>;
-    except(right: UnionBase<Input, Meta>): Union<Input, Meta>;
-    exceptAll(this: UnionBase<Input, IsPostgres | IsMysql>, right: UnionBase<Input, Meta>): Union<Input, Meta>;
+    union(right: UnionBase<Input, Meta> | ((self: Input & HasTarget) => UnionBase<Input, Meta>)): Union<Input, Meta>;
+    unionAll(right: UnionBase<Input, Meta> | ((self: Input & HasTarget) => UnionBase<Input, Meta>)): Union<Input, Meta>;
+    intersect(right: UnionBase<Input, Meta> | ((self: Input & HasTarget) => UnionBase<Input, Meta>)): Union<Input, Meta>;
+    intersectAll(this: UnionBase<Input, IsPostgres | IsMysql>, right: UnionBase<Input, Meta> | ((self: Input & HasTarget) => UnionBase<Input, Meta>)): Union<Input, Meta>;
+    except(right: UnionBase<Input, Meta> | ((self: Input & HasTarget) => UnionBase<Input, Meta>)): Union<Input, Meta>;
+    exceptAll(this: UnionBase<Input, IsPostgres | IsMysql>, right: UnionBase<Input, Meta> | ((self: Input & HasTarget) => UnionBase<Input, Meta>)): Union<Input, Meta>;
 }
-export interface UnionData<Meta extends QueryMeta> extends UnionBaseData<Meta> {
+export interface UnionData<Meta extends QueryMeta = QueryMeta> extends UnionBaseData<Meta> {
     left: HasQuery;
     operator: HasSql;
     right: HasQuery;

package/dist/core/query/Union.js

@@ -6,15 +6,19 @@ import {
   internalSelection
 } from "../Internal.js";
 import { Query } from "../Query.js";
-import { sql } from "../Sql.js";
+import { Sql, sql } from "../Sql.js";
 var UnionBase = class extends Query {
   [internalData];
+  #makeSelf() {
+    const { select } = getData(this);
+    return select.makeVirtual(Sql.SELF_TARGET);
+  }
   union(right) {
     return new Union({
       ...getData(this),
       left: this,
       operator: sql`union`,
-      right
+      right: typeof right === "function" ? right(this.#makeSelf()) : right
     });
   }
   unionAll(right) {
@@ -22,7 +26,7 @@ var UnionBase = class extends Query {
       ...getData(this),
       left: this,
       operator: sql`union all`,
-      right
+      right: typeof right === "function" ? right(this.#makeSelf()) : right
     });
   }
   intersect(right) {
@@ -30,7 +34,7 @@ var UnionBase = class extends Query {
       ...getData(this),
       left: this,
       operator: sql`intersect`,
-      right
+      right: typeof right === "function" ? right(this.#makeSelf()) : right
     });
   }
   intersectAll(right) {
@@ -38,7 +42,7 @@ var UnionBase = class extends Query {
       ...getData(this),
       left: this,
       operator: sql`intersect all`,
-      right
+      right: typeof right === "function" ? right(this.#makeSelf()) : right
     });
   }
   except(right) {
@@ -46,7 +50,7 @@ var UnionBase = class extends Query {
       ...getData(this),
       left: this,
       operator: sql`except`,
-      right
+      right: typeof right === "function" ? right(this.#makeSelf()) : right
     });
   }
   exceptAll(right) {
@@ -54,7 +58,7 @@ var UnionBase = class extends Query {
       ...getData(this),
       left: this,
       operator: sql`except all`,
-      right
+      right: typeof right === "function" ? right(this.#makeSelf()) : right
     });
   }
 };
@@ -64,10 +68,10 @@ var Union = class extends UnionBase {
   constructor(data) {
     super(data);
     this[internalData] = data;
-    this[internalSelection] = data.selection;
+    this[internalSelection] = data.select;
   }
   get [internalQuery]() {
-    return sql.chunk("emitUnion", this);
+    return sql.chunk("emitUnion", getData(this));
   }
 };
 function union(left, right, ...rest) {

package/dist/core/query/Update.js

@@ -50,7 +50,7 @@ var UpdateTable = class _UpdateTable extends Update {
     const data = getData(this);
     return new Update({
       ...data,
-      returning: selection(returning ?? data.table)
+      returning: returning ? selection(returning) : selection.table(data.table)
     });
   }
 };

package/dist/index.d.ts

@@ -1,18 +1,20 @@
 export * from './compat.js';
+export * from './core/Builder.js';
 export * from './core/Column.js';
 export * from './core/Constraint.js';
 export * from './core/Database.js';
 export * from './core/Driver.js';
+export * from './core/Index.js';
+export * from './core/Internal.js';
+export * from './core/Query.js';
+export * from './core/Selection.js';
+export * from './core/Sql.js';
+export * from './core/Table.js';
 export * from './core/expr/Aggregate.js';
 export * from './core/expr/Conditions.js';
 export * from './core/expr/Include.js';
-export * from './core/Index.js';
-export * from './core/Query.js';
 export * from './core/query/Delete.js';
 export * from './core/query/Insert.js';
 export * from './core/query/Select.js';
 export * from './core/query/Union.js';
 export * from './core/query/Update.js';
-export * from './core/Selection.js';
-export * from './core/Sql.js';
-export * from './core/Table.js';

package/dist/index.js

@@ -1,19 +1,21 @@
 // src/index.ts
 export * from "./compat.js";
+export * from "./core/Builder.js";
 export * from "./core/Column.js";
 export * from "./core/Constraint.js";
 export * from "./core/Database.js";
 export * from "./core/Driver.js";
+export * from "./core/Index.js";
+export * from "./core/Internal.js";
+export * from "./core/Query.js";
+export * from "./core/Selection.js";
+export * from "./core/Sql.js";
+export * from "./core/Table.js";
 export * from "./core/expr/Aggregate.js";
 export * from "./core/expr/Conditions.js";
 export * from "./core/expr/Include.js";
-export * from "./core/Index.js";
-export * from "./core/Query.js";
 export * from "./core/query/Delete.js";
 export * from "./core/query/Insert.js";
 export * from "./core/query/Select.js";
 export * from "./core/query/Union.js";
 export * from "./core/query/Update.js";
-export * from "./core/Selection.js";
-export * from "./core/Sql.js";
-export * from "./core/Table.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rado",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "license": "MIT",
   "type": "module",
   "scripts": {
@@ -8,7 +8,7 @@
     "size": "esbuild src/index.ts --bundle --minify --format=esm --outdir=dist",
     "profile": "PROFILE=true bun build.ts && cd bin && (rimraf CPU*.cpuprofile || true) && node --cpu-prof --cpu-prof-interval=100 test && speedscope CPU*.cpuprofile",
     "prepublishOnly": "rm -rf dist && bun run build",
-    "cycles": "madge --warning --circular src/index.ts",
+    "cycles": "madge --circular src/index.ts src/sqlite.ts src/mysql.ts src/postgres.ts",
     "test:bun": "bun test",
     "test:node": "node --test-force-exit --test-concurrency=1 --import tsx --test \"**/*.test.ts\"",
     "test:deno": "deno test --no-check --allow-read"