rado 1.2.1 → 1.3.0-preview.1

package/dist/core/query/Select.js

@@ -1,12 +1,17 @@
 // src/core/query/Select.ts
+import { and } from "../expr/Conditions.js";
 import {
   getData,
+  getField,
   getQuery,
   getSelection,
   getSql,
+  getTable,
   getTarget,
+  hasField,
   hasSelection,
   hasSql,
+  hasTable,
   hasTarget,
   internalData,
   internalQuery,
@@ -19,9 +24,23 @@ import {
   selection
 } from "../Selection.js";
 import { Sql, sql } from "../Sql.js";
-import { and } from "../expr/Conditions.js";
 import { formatCTE } from "./CTE.js";
 import { formatModifiers } from "./Shared.js";
+function isUnionQuery(query) {
+  return Array.isArray(query.select);
+}
+function mapScalarSelection(query, selected) {
+  if (hasSql(selected)) return query.mapWith(getSql(selected));
+  if (selected && typeof selected === "object") {
+    const values = Object.values(selected);
+    if (values.length === 1) {
+      const first = values[0];
+      if (first && typeof first === "object" && hasSql(first))
+        return query.mapWith(getSql(first));
+    }
+  }
+  return query;
+}
 var SelectFirst = class extends SingleQuery {
   [internalData];
   constructor(data) {
@@ -36,7 +55,10 @@ var SelectFirst = class extends SingleQuery {
     return selectQuery(getData(this));
   }
   get [internalSql]() {
-    return sql`(${getQuery(this)})`;
+    return mapScalarSelection(
+      sql`(${getQuery(this)})`,
+      getSelection(this).input
+    );
   }
 };
 var UnionBase = class extends SingleQuery {
@@ -46,9 +68,14 @@ var UnionBase = class extends SingleQuery {
     this[internalData] = data;
   }
   as(alias) {
-    const fields = getSelection(this).makeVirtual(alias);
-    return Object.assign(fields, {
+    const selected = getSelection(this);
+    const fields = selected.makeVirtual(alias);
+    return Object.assign({}, fields, {
       [internalSelection]: selection(fields),
+      [internalSql]: mapScalarSelection(
+        sql`(${getQuery(this)})`,
+        selected.input
+      ),
       [internalTarget]: sql`(${getQuery(this)}) as ${sql.identifier(
         alias
       )}`.inlineFields(true)
@@ -63,15 +90,73 @@ var UnionBase = class extends SingleQuery {
     if (!("compound" in data)) throw new Error("No compound defined");
     return data.compound;
   }
+  #selectFields(select) {
+    return querySelection(select).fieldNames();
+  }
+  #segmentSelect(segment) {
+    const query = segment;
+    if (isUnionQuery(query)) return query.select[0];
+    if ("union" in segment) return this.#segmentSelect(segment.union);
+    if ("unionAll" in segment) return this.#segmentSelect(segment.unionAll);
+    if ("intersect" in segment) return this.#segmentSelect(segment.intersect);
+    if ("intersectAll" in segment)
+      return this.#segmentSelect(segment.intersectAll);
+    if ("except" in segment) return this.#segmentSelect(segment.except);
+    if ("exceptAll" in segment) return this.#segmentSelect(segment.exceptAll);
+    return segment;
+  }
+  #unionSegment(op, query) {
+    switch (op) {
+      case "union":
+        return { union: query };
+      case "unionAll":
+        return { unionAll: query };
+      case "intersect":
+        return { intersect: query };
+      case "intersectAll":
+        return { intersectAll: query };
+      case "except":
+        return { except: query };
+      case "exceptAll":
+        return { exceptAll: query };
+    }
+  }
+  #assertMatchingFields(left, right) {
+    const fields = this.#selectFields(left[0]);
+    const assert = (query) => {
+      const names = this.#selectFields(query);
+      if (fields.length !== names.length)
+        throw new Error("Union segments must have the same fields");
+      for (let i = 0; i < fields.length; i++)
+        if (fields[i] !== names[i])
+          throw new Error("Union segments must have the same fields");
+    };
+    for (const segment of left.slice(1)) assert(this.#segmentSelect(segment));
+    for (const segment of right) assert(this.#segmentSelect(segment));
+  }
+  #appendCompound(left, op, right) {
+    const [firstRight, ...restRight] = right.select;
+    if (restRight.length === 0)
+      return [...left, this.#unionSegment(op, firstRight)];
+    return [...left, this.#unionSegment(op, right)];
+  }
   #compound(op, target) {
     const left = this.#getSelect(this);
-    const right = this.#getSelect(
-      typeof target === "function" ? target(this.#makeSelf()) : target
-    );
-    const [on, ...rest] = right;
-    const select = [...left, { [op]: on }, ...rest];
+    const rightBase = typeof target === "function" ? target(this.#makeSelf()) : target;
+    const rightData = getData(rightBase);
+    const rightSelect = this.#getSelect(rightBase);
+    const right = { ...rightData, select: rightSelect };
+    this.#assertMatchingFields(left, rightSelect);
+    const select = this.#appendCompound(left, op, right);
+    const {
+      resolver,
+      with: withDefs,
+      withRecursive
+    } = getData(this);
     return new Union({
-      ...getData(this),
+      resolver,
+      with: withDefs,
+      withRecursive,
       select
     });
   }
@@ -94,6 +179,7 @@ var UnionBase = class extends SingleQuery {
     return this.#compound("exceptAll", target);
   }
 };
+var forKeywords = ["update", "no key update", "share", "key share"];
 var Select = class _Select extends UnionBase {
   [internalData];
   constructor(data) {
@@ -105,6 +191,18 @@ var Select = class _Select extends UnionBase {
   from(from) {
     return new _Select({ ...getData(this), from });
   }
+  for(keyword, config = {}) {
+    if (!forKeywords.includes(keyword))
+      throw new Error(`Invalid FOR keyword: ${keyword}`);
+    return new _Select({
+      ...getData(this),
+      for: sql.query(sql.unsafe(keyword), {
+        of: config.of && sql.join([config.of].flat().map(getTarget), sql`, `),
+        nowait: config.noWait,
+        skipLocked: config.skipLocked
+      })
+    });
+  }
   #fromTarget() {
     const { from } = getData(this);
     if (!from) throw new Error("No target defined");
@@ -117,17 +215,26 @@ var Select = class _Select extends UnionBase {
   leftJoin(leftJoin, on) {
     return this.#join({ leftJoin, on });
   }
+  leftJoinLateral(leftJoinLateral, on) {
+    return this.#join({ leftJoinLateral, on });
+  }
   rightJoin(rightJoin, on) {
     return this.#join({ rightJoin, on });
   }
   innerJoin(innerJoin, on) {
     return this.#join({ innerJoin, on });
   }
+  innerJoinLateral(innerJoinLateral, on) {
+    return this.#join({ innerJoinLateral, on });
+  }
   fullJoin(fullJoin, on) {
     return this.#join({ fullJoin, on });
   }
-  crossJoin(crossJoin, on) {
-    return this.#join({ crossJoin, on });
+  crossJoin(crossJoin) {
+    return this.#join({ crossJoin });
+  }
+  crossJoinLateral(crossJoinLateral) {
+    return this.#join({ crossJoinLateral });
   }
   where(...where) {
     return new _Select({ ...getData(this), where: and(...where) });
@@ -163,17 +270,101 @@ var Select = class _Select extends UnionBase {
     return sql`(${getQuery(this)})`;
   }
 };
+function collectReferencedTargets(input, names) {
+  if (hasSql(input)) {
+    if (hasField(input)) {
+      const field = getField(input);
+      const source = field.source;
+      if (!(source && typeof source === "object" && hasSql(source)))
+        names.add(field.targetName);
+    }
+    return;
+  }
+  if (!input || typeof input !== "object") return;
+  for (const value of Object.values(input))
+    collectReferencedTargets(value, names);
+}
+function collectFromTargets(from, names) {
+  if (!from) return;
+  const collect = (target) => {
+    if (hasTable(target)) {
+      names.add(getTable(target).aliased);
+      return;
+    }
+    if (!hasSelection(target)) return;
+    collectReferencedTargets(getSelection(target).input, names);
+  };
+  if (Array.isArray(from)) {
+    for (const entry of from) {
+      if (hasTarget(entry)) collect(entry);
+      else if (!hasSql(entry)) {
+        const { target } = joinOp(entry);
+        if (hasTarget(target)) collect(target);
+      }
+    }
+    return;
+  }
+  if (hasTarget(from)) collect(from);
+}
+function hasUnnamedDerivedSource(input) {
+  if (hasField(input)) {
+    const source = getField(input).source;
+    if (source && typeof source === "object" && hasSql(source)) {
+      const sourceSql = source;
+      if (!hasField(sourceSql) && !getSql(sourceSql).alias) return true;
+    }
+    return false;
+  }
+  if (hasSql(input)) return false;
+  if (!input || typeof input !== "object") return false;
+  return Object.values(input).some(
+    hasUnnamedDerivedSource
+  );
+}
 function querySelection({ select, from }) {
-  if (select) return selection(select);
+  if (select) {
+    if (from) {
+      const selectedTargets = /* @__PURE__ */ new Set();
+      const fromTargets = /* @__PURE__ */ new Set();
+      collectReferencedTargets(select, selectedTargets);
+      collectFromTargets(from, fromTargets);
+      if (fromTargets.size > 0) {
+        for (const targetName of selectedTargets)
+          if (!fromTargets.has(targetName))
+            throw new Error(`Unknown target in select: ${targetName}`);
+      }
+    }
+    if (hasSql(select) && hasSelection(select)) {
+      const selected = getSelection(select);
+      if (!from || !Array.isArray(from)) return selected;
+      const [, ...joins2] = from;
+      return applyJoins(selected, joins2);
+    }
+    if (!from || !Array.isArray(from))
+      return selection(select);
+    const [, ...joins] = from;
+    return applyJoins(selection(select), joins);
+  }
   if (!from) throw new Error("No selection defined");
   if (Array.isArray(from)) {
     const [target, ...joins] = from;
-    return joins.reduce((result, join) => {
-      const { target: target2, op } = joinOp(join);
-      return result.join(target2, op);
-    }, selection(target));
+    return applyJoins(selection(target), joins);
   }
-  return hasSelection(from) ? getSelection(from) : selection(sql`*`);
+  if (hasSelection(from)) {
+    const selected = getSelection(from);
+    if (hasUnnamedDerivedSource(selected.input))
+      throw new Error("Cannot select all from subquery without alias");
+    return selected;
+  }
+  return selection(sql`*`);
+}
+function applyJoins(base, joins) {
+  let current = base;
+  for (const join of joins) {
+    const { target, op } = joinOp(join);
+    current = current.join(target, op);
+  }
+  return current;
 }
 function joinOp(join) {
   const { on, ...rest } = join;
@@ -181,22 +372,26 @@ function joinOp(join) {
   const target = rest[op];
   return { target, op, on };
 }
+function formatTarget(target) {
+  if (hasTable(target)) return getTable(target).target();
+  return getTarget(target);
+}
 function formatFrom(from) {
   if (!from) throw new Error("No target defined");
   if (Array.isArray(from)) {
     return sql.join(
       from.map((join) => {
-        if (hasTarget(join)) return getTarget(join);
+        if (hasTarget(join)) return formatTarget(join);
         if (hasSql(join)) return getSql(join);
         const { target, op, on } = joinOp(join);
         return sql.query({
-          [op]: hasTarget(target) ? getTarget(target) : getSql(target),
+          [op]: hasTarget(target) ? formatTarget(target) : getSql(target),
           on
         });
       })
     );
   }
-  return hasTarget(from) ? getTarget(from) : getSql(from);
+  return hasTarget(from) ? formatTarget(from) : getSql(from);
 }
 function selectQuery(query) {
   const { from, where, groupBy, having, distinct, distinctOn } = query;
@@ -208,11 +403,12 @@ function selectQuery(query) {
     {
       select,
       from: from && formatFrom(from),
+      for: query.for,
       where,
       groupBy: groupBy && sql.join(groupBy, sql`, `),
       having: typeof having === "function" ? having(selected.input) : having
     },
-    formatModifiers(query)
+    formatModifiers(query, selected)
   );
 }
 var Union = class _Union extends UnionBase {
@@ -281,19 +477,33 @@ function exceptAll(left, right, ...rest) {
 function unionQuery(query) {
   const { select } = query;
   let fields;
+  const firstSelect = (query2) => isUnionQuery(query2) ? query2.select[0] : query2;
+  const segmentQuery = (query2) => {
+    if (isUnionQuery(query2)) {
+      const nested = unionQuery(query2);
+      return sql.universal({
+        sqlite: sql`select * from (${nested})`,
+        default: sql`(${nested})`
+      });
+    }
+    const inner = selectQuery(query2);
+    return query2.orderBy || query2.limit !== void 0 || query2.offset !== void 0 ? sql`(${inner})` : inner;
+  };
   const segments = sql.join(
     select.map((segment, i) => {
       if (i === 0) {
         fields = querySelection(segment).fieldNames();
-        return selectQuery(segment);
+        return segmentQuery(segment);
       }
       const op = Object.keys(segment)[0];
       const query2 = segment[op];
-      const names = querySelection(query2).fieldNames();
+      const names = querySelection(firstSelect(query2)).fieldNames();
+      if (fields.length !== names.length)
+        throw new Error("Union segments must have the same fields");
       for (let i2 = 0; i2 < fields.length; i2++)
         if (fields[i2] !== names[i2])
           throw new Error("Union segments must have the same fields");
-      return sql.query({ [op]: selectQuery(query2) });
+      return sql.query({ [op]: segmentQuery(query2) });
     })
   );
   return sql.query(formatCTE(query), segments, formatModifiers(query));

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

@@ -1,3 +1,4 @@
+import type { Selection } from '../Selection.js';
 import { type Sql } from '../Sql.js';
 import type { ResultModifiers } from './Query.js';
-export declare function formatModifiers(modifiers: ResultModifiers): Sql | undefined;
+export declare function formatModifiers(modifiers: ResultModifiers, selected?: Selection): Sql | undefined;

package/dist/core/query/Shared.js

@@ -1,20 +1,23 @@
 // src/core/query/Shared.ts
+import { input } from "../expr/Input.js";
 import { getSql } from "../Internal.js";
 import { sql } from "../Sql.js";
-import { input } from "../expr/Input.js";
-function formatModifiers(modifiers) {
+function formatModifiers(modifiers, selected) {
   const { orderBy, limit, offset } = modifiers;
-  if (!orderBy && limit === void 0 && offset === void 0) return void 0;
+  const normalizedLimit = typeof limit === "number" && limit < 0 ? void 0 : limit;
+  if (!orderBy && normalizedLimit === void 0 && offset === void 0)
+    return void 0;
   return sql.query({
     orderBy: orderBy && sql.join(
       orderBy.map((part) => {
-        const { alias } = getSql(part);
+        const inner = getSql(part);
+        const alias = selected?.aliasOf(part) ?? inner.alias;
         if (alias) return sql.identifier(alias);
         return part;
       }),
       sql`, `
     ),
-    limit: limit !== void 0 && input(limit),
+    limit: normalizedLimit !== void 0 && input(normalizedLimit),
     offset: offset !== void 0 && input(offset)
   });
 }

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

@@ -1,24 +1,24 @@
+import { type Input as UserInput } from '../expr/Input.js';
 import { type HasQuery, type HasSql, internalData, internalQuery, internalSelection } from '../Internal.js';
 import type { IsPostgres, IsSqlite, QueryMeta } from '../MetaData.js';
 import { type QueryData, SingleQuery } from '../Queries.js';
 import { type Selection, type SelectionInput, type SelectionRow } from '../Selection.js';
 import { type Sql } from '../Sql.js';
-import type { TableDefinition, TableRow, TableUpdate } from '../Table.js';
-import { type Input } from '../expr/Input.js';
+import type { TableDefinition, TableFields, TableUpdate } from '../Table.js';
 import type { UpdateQuery } from './Query.js';
-export declare class Update<Result, Meta extends QueryMeta = QueryMeta> extends SingleQuery<Array<Result>, Meta> implements HasQuery<Result> {
+export declare class Update<Input, Meta extends QueryMeta = QueryMeta> extends SingleQuery<Array<SelectionRow<Input>>, Meta> implements HasQuery<Array<SelectionRow<Input>>> {
     readonly [internalData]: QueryData<Meta> & UpdateQuery;
     readonly [internalSelection]?: Selection;
     constructor(data: QueryData<Meta> & UpdateQuery);
-    get [internalQuery](): Sql<Result>;
-    limit(limit: Input<number>): Update<Result, Meta>;
-    offset(offset: Input<number>): Update<Result, Meta>;
-    orderBy(...orderBy: Array<HasSql>): Update<Result, Meta>;
+    get [internalQuery](): Sql<Array<SelectionRow<Input>>>;
+    limit(limit: UserInput<number>): Update<Input, Meta>;
+    offset(offset: UserInput<number>): Update<Input, Meta>;
+    orderBy(...orderBy: Array<HasSql>): Update<Input, Meta>;
 }
 export declare class UpdateTable<Definition extends TableDefinition, Meta extends QueryMeta> extends Update<void, Meta> {
     set(set: TableUpdate<Definition>): UpdateTable<Definition, Meta>;
     where(...where: Array<HasSql<boolean> | undefined>): UpdateTable<Definition, Meta>;
-    returning(this: UpdateTable<Definition, IsPostgres | IsSqlite>): Update<TableRow<Definition>, Meta>;
-    returning<Input extends SelectionInput>(this: UpdateTable<Definition, IsPostgres | IsSqlite>, returning?: Input): Update<SelectionRow<Input>, Meta>;
+    returning(this: UpdateTable<Definition, IsPostgres | IsSqlite>): Update<TableFields<Definition>, Meta>;
+    returning<Input extends SelectionInput>(this: UpdateTable<Definition, IsPostgres | IsSqlite>, returning?: Input): Update<Input, Meta>;
 }
 export declare function updateQuery(query: UpdateQuery): Sql;

package/dist/core/query/Update.js

@@ -1,4 +1,6 @@
 // src/core/query/Update.ts
+import { and } from "../expr/Conditions.js";
+import { mapToColumn } from "../expr/Input.js";
 import {
   getData,
   getTable,
@@ -11,8 +13,6 @@ import {
   selection
 } from "../Selection.js";
 import { sql } from "../Sql.js";
-import { and } from "../expr/Conditions.js";
-import { mapToColumn } from "../expr/Input.js";
 import { formatCTE } from "./CTE.js";
 import { formatModifiers } from "./Shared.js";
 var Update = class _Update extends SingleQuery {
@@ -37,7 +37,17 @@ var Update = class _Update extends SingleQuery {
 };
 var UpdateTable = class _UpdateTable extends Update {
   set(set) {
-    return new _UpdateTable({ ...getData(this), set });
+    const data = getData(this);
+    const hasDefinedValue = Object.values(set).some(
+      (value) => value !== void 0
+    );
+    if (!hasDefinedValue) {
+      const hasOnUpdate = Object.values(getTable(data.update).columns).some(
+        (column) => !!getData(column).$onUpdate
+      );
+      if (!hasOnUpdate) throw new Error("No values to set");
+    }
+    return new _UpdateTable({ ...data, set });
   }
   where(...where) {
     return new _UpdateTable({
@@ -54,26 +64,28 @@ function updateQuery(query) {
   const { update: table, set: values, where, returning } = query;
   const tableApi = getTable(table);
   if (!values) throw new Error("Update values are required");
-  const set = sql.join(
-    Object.entries(tableApi.columns).map(([key, column]) => {
+  const assignments = Object.entries(tableApi.columns).flatMap(
+    ([key, column]) => {
       const columnApi = getData(column);
       const { name, $onUpdate } = columnApi;
+      const value = values[key];
       let expr;
-      if (!(key in values)) {
+      if (value === void 0) {
         if ($onUpdate) expr = $onUpdate();
-        else return;
+        else return [];
       } else {
-        expr = mapToColumn(columnApi, values[key]);
+        expr = mapToColumn(columnApi, value);
       }
       const fieldName = name ?? key;
-      return sql`${sql.identifier(fieldName)} = ${expr}`;
-    }),
-    sql`, `
+      return [sql`${sql.identifier(fieldName)} = ${expr}`];
+    }
   );
+  if (assignments.length === 0) throw new Error("No values to set");
+  const set = sql.join(assignments, sql`, `);
   return sql.query(
     formatCTE(query),
     {
-      update: sql.identifier(tableApi.name),
+      update: tableApi.identifier(),
       set,
       where,
       returning: returning && selection(returning)

package/dist/driver/better-sqlite3.js

@@ -8,6 +8,8 @@ var PreparedStatement = class {
     this.stmt = stmt;
     this.isSelection = isSelection;
   }
+  stmt;
+  isSelection;
   all(params) {
     return this.stmt.all(...params);
   }
@@ -31,6 +33,8 @@ var BetterSqlite3Driver = class _BetterSqlite3Driver {
     this.client = client;
     this.depth = depth;
   }
+  client;
+  depth;
   parsesJson = false;
   supportsTransactions = true;
   exec(query) {

package/dist/driver/bun-sqlite.js

@@ -7,6 +7,7 @@ var PreparedStatement = class {
   constructor(stmt) {
     this.stmt = stmt;
   }
+  stmt;
   all(params) {
     return this.stmt.all(...params);
   }
@@ -28,6 +29,8 @@ var BunSqliteDriver = class _BunSqliteDriver {
     this.client = client;
     this.depth = depth;
   }
+  client;
+  depth;
   parsesJson = false;
   supportsTransactions = true;
   exec(query) {

package/dist/driver/d1.js

@@ -7,6 +7,8 @@ var PreparedStatement = class {
     this.stmt = stmt;
     this.isSelection = isSelection;
   }
+  stmt;
+  isSelection;
   async all(params) {
     return this.stmt.bind(...params).all().then(({ results }) => results);
   }
@@ -28,6 +30,7 @@ var D1Driver = class {
   constructor(client) {
     this.client = client;
   }
+  client;
   parsesJson = false;
   supportsTransactions = false;
   async exec(query) {

package/dist/driver/libsql.js

@@ -7,6 +7,8 @@ var PreparedStatement = class {
     this.client = client;
     this.sql = sql;
   }
+  client;
+  sql;
   async all(params) {
     const result = await this.client.execute({ sql: this.sql, args: params });
     return result.rows;
@@ -29,6 +31,8 @@ var LibSQLClient = class _LibSQLClient {
     this.client = client;
     this.depth = depth;
   }
+  client;
+  depth;
   parsesJson = false;
   supportsTransactions = true;
   async exec(query) {

package/dist/driver/mysql2.js

@@ -9,6 +9,9 @@ var PreparedStatement = class {
     this.sql = sql;
     this.name = name;
   }
+  client;
+  sql;
+  name;
   #transformParam = (param) => {
     if (param instanceof Uint8Array) return Buffer.from(param);
     return param;
@@ -37,6 +40,8 @@ var Mysql2Driver = class _Mysql2Driver {
     this.client = client;
     this.depth = depth;
   }
+  client;
+  depth;
   parsesJson = true;
   supportsTransactions = true;
   async exec(query) {

package/dist/driver/pg.d.ts

@@ -2,6 +2,22 @@ import type { Client, Pool, PoolClient } from 'pg';
 import { AsyncDatabase, type TransactionOptions } from '../core/Database.js';
 import type { AsyncDriver, AsyncStatement, BatchedQuery, PrepareOptions } from '../core/Driver.js';
 type Queryable = Client | Pool | PoolClient;
+/**
+ * The query interface used by the driver. Packages providing a pg-compatible
+ * client, such as @vercel/postgres and @neondatabase/serverless, ship their
+ * own copy of the pg types which are not directly assignable to pg's. They
+ * are accepted through this minimal structural interface instead.
+ */
+export interface PgCompatible {
+    query(queryConfig: {
+        name?: string;
+        text: string;
+        values?: Array<unknown>;
+        rowMode?: string;
+    }): Promise<{
+        rows: Array<any>;
+    }>;
+}
 declare class PreparedStatement implements AsyncStatement {
     private client;
     private sql;
@@ -25,5 +41,5 @@ export declare class PgDriver implements AsyncDriver {
     batch(queries: Array<BatchedQuery>): Promise<Array<Array<unknown>>>;
     transaction<T>(run: (inner: AsyncDriver) => Promise<T>, options: TransactionOptions['postgres']): Promise<T>;
 }
-export declare function connect(client: Queryable): AsyncDatabase<'postgres'>;
+export declare function connect(client: PgCompatible): AsyncDatabase<'postgres'>;
 export {};