rado 1.0.14 → 1.2.0

package/dist/core/Sql.js

@@ -1,122 +1,65 @@
 // src/core/Sql.ts
-import { getSql, hasSql, internalSql } from "./Internal.js";
-var Chunk = class {
-  constructor(type, inner) {
-    this.type = type;
-    this.inner = inner;
-  }
+import {
+  getSql,
+  getTarget,
+  hasSql,
+  hasTarget,
+  internalSql
+} from "./Internal.js";
+var noop = () => {
 };
 var Sql = class _Sql {
+  constructor(emit = noop) {
+    this.emit = emit;
+  }
   static SELF_TARGET = "$$self";
   alias;
   mapFromDriverValue;
   [internalSql] = this;
-  #chunks;
-  constructor(chunks = []) {
-    this.#chunks = chunks;
-  }
   as(name) {
     this.alias = name;
     return this;
   }
   mapWith(decoder) {
     const res = this;
-    res.mapFromDriverValue = typeof decoder === "function" ? decoder : decoder.mapFromDriverValue;
+    res.mapFromDriverValue = typeof decoder === "function" ? (input) => input === null ? null : decoder(input) : decoder.mapFromDriverValue;
     return res;
   }
-  chunk(type, inner) {
-    this.#chunks.push(new Chunk(type, inner));
-    return this;
-  }
-  unsafe(sql2) {
-    if (sql2.length > 0) this.chunk("emitUnsafe", sql2);
-    return this;
-  }
-  field(field) {
-    return this.chunk("emitField", field);
-  }
-  add(sql2) {
-    const inner = getSql(sql2);
-    if (!(inner instanceof _Sql)) throw new Error("Invalid SQL");
-    this.#chunks.push(...inner.#chunks);
-    return this;
-  }
-  value(value) {
-    return this.chunk("emitValue", value);
-  }
-  getValue() {
-    if (this.#chunks.length !== 1) return;
-    const chunk = this.#chunks[0];
-    if (chunk?.type === "emitValue") return chunk.inner;
+  inlineFields(withTableName) {
+    return new _Sql((emitter) => emitter.inlineFields(this, withTableName));
   }
-  inline(value) {
-    return this.chunk("emitInline", value);
+  inlineValues() {
+    return new _Sql((emitter) => emitter.inlineValues(this));
   }
-  jsonPath(path) {
-    const inner = path.target.#chunks[0];
-    if (inner?.type !== "emitJsonPath") return this.chunk("emitJsonPath", path);
-    const innerPath = inner.inner;
-    return this.chunk("emitJsonPath", {
-      ...innerPath,
-      segments: [...innerPath.segments, ...path.segments]
-    });
+  nameSelf(name) {
+    return new _Sql((emitter) => emitter.emitSelf(this, name));
   }
   forSelection() {
-    if (this.#chunks.length === 1) {
-      const first = this.#chunks[0];
-      if (first.type === "emitJsonPath")
-        return sql.jsonPath({ ...first.inner, asSql: false }).mapWith(this);
-    }
     return this;
   }
-  placeholder(name) {
-    return this.chunk("emitPlaceholder", name);
-  }
-  identifier(identifier) {
-    return this.chunk("emitIdentifierOrSelf", identifier);
-  }
-  inlineValues() {
-    return new _Sql(
-      this.#chunks.map((chunk) => {
-        if (chunk.type !== "emitValue") return chunk;
-        return new Chunk("emitInline", chunk.inner);
-      })
-    );
-  }
-  inlineFields(withTableName) {
-    return new _Sql(
-      this.#chunks.flatMap((chunk) => {
-        if (chunk.type !== "emitField") return [chunk];
-        const data = chunk.inner;
-        if (withTableName)
-          return [
-            new Chunk("emitIdentifierOrSelf", data.targetName),
-            new Chunk("emitUnsafe", "."),
-            new Chunk("emitIdentifier", data.fieldName)
-          ];
-        return [new Chunk("emitIdentifier", data.fieldName)];
-      })
-    );
-  }
-  nameSelf(name) {
-    return sql.chunk("emitSelf", { name, inner: this });
+};
+var JsonPathSql = class extends Sql {
+  constructor(path) {
+    super((emitter) => emitter.emitJsonPath(path));
+    this.path = path;
   }
-  emitTo(emitter) {
-    for (const chunk of this.#chunks) emitter[chunk.type](chunk.inner);
+  forSelection() {
+    return sql.jsonPath({ ...this.path, asSql: false }).mapWith(this);
   }
 };
 function sql(strings, ...inner) {
-  const sql2 = new Sql();
-  for (let i = 0; i < strings.length; i++) {
-    sql2.unsafe(strings[i]);
-    if (i < inner.length) {
-      const insert = inner[i];
-      if (insert !== null && typeof insert === "object" && hasSql(insert))
-        sql2.add(insert);
-      else sql2.value(insert);
+  return new Sql((emitter) => {
+    for (let i = 0; i < strings.length; i++) {
+      emitter.emitUnsafe(strings[i]);
+      if (i < inner.length) {
+        const insert = inner[i];
+        const isObject = insert !== null && typeof insert === "object";
+        if (isObject && hasSql(insert)) getSql(insert).emit(emitter);
+        else if (isObject && hasTarget(insert)) getTarget(insert).emit(emitter);
+        else emitter.emitValueOrInline(insert);
+      }
     }
-  }
-  return sql2;
+  });
 }
 ((sql2) => {
   function empty() {
@@ -124,61 +67,67 @@ function sql(strings, ...inner) {
   }
   sql2.empty = empty;
   function unsafe(directSql) {
-    return empty().unsafe(String(directSql));
+    return new Sql((emitter) => emitter.emitUnsafe(String(directSql)));
   }
   sql2.unsafe = unsafe;
   function value(value2) {
-    return empty().value(value2);
+    return new Sql((emitter) => emitter.emitValueOrInline(value2));
   }
   sql2.value = value;
   function inline(value2) {
-    return empty().inline(value2);
+    return new Sql((emitter) => emitter.emitInline(value2));
   }
   sql2.inline = inline;
   function placeholder(name) {
-    return empty().placeholder(name);
+    return new Sql((emitter) => emitter.emitPlaceholder(name));
   }
   sql2.placeholder = placeholder;
   function identifier(identifier2) {
-    return empty().identifier(identifier2);
+    return new Sql((emitter) => emitter.emitIdentifierOrSelf(identifier2));
   }
   sql2.identifier = identifier;
   function field(field2) {
-    return empty().field(field2);
+    return new Sql((emitter) => emitter.emitField(field2));
   }
   sql2.field = field;
   function jsonPath(path) {
-    return empty().jsonPath(path);
+    if (path.target instanceof JsonPathSql) {
+      const inner = path.target.path;
+      return new JsonPathSql({
+        ...inner,
+        segments: [...inner.segments, ...path.segments]
+      });
+    }
+    return new JsonPathSql(path);
   }
   sql2.jsonPath = jsonPath;
-  function chunk(type, inner) {
-    return empty().chunk(type, inner);
-  }
-  sql2.chunk = chunk;
   function universal(runtimes) {
-    return empty().chunk("emitUniversal", runtimes);
+    return new Sql((emitter) => emitter.emitUniversal(runtimes));
   }
   sql2.universal = universal;
-  function query(ast) {
+  function query(...chunks) {
     return join(
-      Object.entries(ast).map(([key, value2]) => {
-        const statement = key.replace(/([A-Z])/g, " $1").toLocaleLowerCase();
-        if (value2 === true) return sql2.unsafe(statement);
-        if (Array.isArray(value2)) value2 = join(value2);
-        if (!key) return value2;
-        return value2 && sql2`${sql2.unsafe(statement)} ${value2}`;
+      chunks.filter(Boolean).flatMap((chunk) => {
+        if (hasSql(chunk)) return chunk;
+        return Object.entries(chunk).map(([key, value2]) => {
+          const statement = key.replace(/([A-Z])/g, " $1").toLowerCase();
+          if (value2 === true) return sql2.unsafe(statement);
+          if (Array.isArray(value2)) value2 = join(value2);
+          if (!key) return value2;
+          return value2 && sql2`${sql2.unsafe(statement)} ${value2}`;
+        });
       })
     );
   }
   sql2.query = query;
   function join(items, separator = sql2` `) {
     const parts = items.filter(Boolean);
-    const sql3 = new Sql();
-    for (let i = 0; i < parts.length; i++) {
-      if (i > 0) sql3.add(separator);
-      sql3.add(parts[i]);
-    }
-    return sql3;
+    return new Sql((emitter) => {
+      for (let i = 0; i < parts.length; i++) {
+        if (i > 0) separator.emit(emitter);
+        getSql(parts[i]).emit(emitter);
+      }
+    });
   }
   sql2.join = join;
 })(sql || (sql = {}));

package/dist/core/Table.d.ts

@@ -1,7 +1,7 @@
-import type { Column, JsonColumn, RequiredColumn } from './Column.js';
+import { type Column, type JsonColumn, type RequiredColumn } from './Column.js';
 import type { ForeignKeyConstraint, PrimaryKeyConstraint, UniqueConstraint } from './Constraint.js';
 import { Index } from './Index.js';
-import { type HasSql, type HasTable, type HasTarget } from './Internal.js';
+import { type HasSelection, type HasSql, type HasTable } from './Internal.js';
 import { type Sql } from './Sql.js';
 import { Field } from './expr/Field.js';
 import type { Input } from './expr/Input.js';
@@ -31,7 +31,7 @@ export declare class TableApi<Definition extends TableDefinition = TableDefiniti
     drop(): Sql;
     indexes(): Record<string, Index>;
 }
-export type Table<Definition extends TableDefinition = Record<never, Column>, Name extends string = string> = TableFields<Definition, Name> & HasTable<Definition, Name> & HasTarget;
+export type Table<Definition extends TableDefinition = Record<never, Column>, Name extends string = string> = TableFields<Definition, Name> & HasTable<Definition, Name> & HasSelection;
 export type TableFields<Definition extends TableDefinition, TableName extends string = string> = {
     [K in keyof Definition]: Definition[K] extends JsonColumn<infer T> ? JsonExpr<T> : Definition[K] extends Column<infer T> ? Field<T, TableName> : never;
 };
@@ -54,4 +54,8 @@ export interface TableConfig<Name extends string = string> extends Record<string
 }
 export declare function table<Definition extends TableDefinition, Name extends string>(name: Name, columns: Definition, config?: (self: Table<Definition, Name>) => TableConfig<Name>, schemaName?: string): Table<Definition, Name>;
 export declare function alias<Definition extends TableDefinition, Alias extends string>(table: Table<Definition>, alias: Alias): Table<Definition, Alias>;
+export declare function tableCreator(nameTable: (name: string) => string): typeof table;
+export type InsertRow<T> = T extends Table<infer Definition> ? TableInsert<Definition> : never;
+export type SelectRow<T> = T extends Table<infer Definition> ? TableRow<Definition> : never;
+export type UpdateRow<T> = T extends Table<infer Definition> ? TableUpdate<Definition> : never;
 export {};

package/dist/core/Table.js

@@ -1,13 +1,18 @@
 // src/core/Table.ts
+import {
+  formatColumn
+} from "./Column.js";
 import { Index } from "./Index.js";
 import {
   getConstraint,
   getData,
   getTable,
   hasConstraint,
+  internalSelection,
   internalTable,
   internalTarget
 } from "./Internal.js";
+import { selection } from "./Selection.js";
 import { sql } from "./Sql.js";
 import { Field } from "./expr/Field.js";
 import { jsonExpr } from "./expr/Json.js";
@@ -42,17 +47,18 @@ var TableApi = class extends TableData {
     const columnData = this.columns[name];
     const column = getData(columnData);
     const columnName = sql.identifier(column.name ?? name);
-    return sql`${columnName} ${sql.chunk("emitColumn", column)}`;
+    return sql`${columnName} ${formatColumn(column)}`;
   }
   createDefinition() {
     const createColumns = keys(this.columns).map(
       (name) => this.columnDefinition(name)
     );
-    const createConstraints = entries(this.config ?? {}).filter(([, constraint]) => hasConstraint(constraint)).map(
-      ([name, constraint]) => sql`constraint ${sql.identifier(name)} ${getConstraint(
+    const createConstraints = entries(this.config ?? {}).filter(([, constraint]) => hasConstraint(constraint)).map(([key, constraint]) => {
+      const { name } = getData(constraint);
+      return sql`constraint ${sql.identifier(name ?? key)} ${getConstraint(
         constraint
-      )}`
-    );
+      )}`;
+    });
     return sql.join(createColumns.concat(createConstraints), sql`, `);
   }
   listColumns() {
@@ -94,7 +100,7 @@ var TableApi = class extends TableData {
     return [this.createTable(), ...this.createIndexes()];
   }
   drop() {
-    return sql`drop table ${this.target()}`;
+    return sql`drop table if exists ${this.target()}`;
   }
   indexes() {
     return fromEntries(
@@ -108,10 +114,12 @@ function table(name, columns, config, schemaName) {
     schemaName,
     columns
   });
+  const fields = api.fields();
   const table2 = {
     [internalTable]: api,
     [internalTarget]: api.target(),
-    ...api.fields()
+    [internalSelection]: selection(fields),
+    ...fields
   };
   if (config) api.config = config(table2);
   return table2;
@@ -121,14 +129,22 @@ function alias(table2, alias2) {
     ...getTable(table2),
     alias: alias2
   });
+  const fields = api.fields();
   return {
     [internalTable]: api,
     [internalTarget]: api.target(),
+    [internalSelection]: selection(fields),
     ...api.fields()
   };
 }
+function tableCreator(nameTable) {
+  return (name, columns, config, schemaName) => {
+    return table(nameTable(name), columns, config, schemaName);
+  };
+}
 export {
   TableApi,
   alias,
-  table
+  table,
+  tableCreator
 };

package/dist/core/Virtual.d.ts

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

package/dist/core/Virtual.js

@@ -3,25 +3,26 @@ 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 target = {
+    [internalTarget]: sql.identifier(alias)
+  };
+  if (!source || typeof source !== "object")
+    throw new Error("Cannot alias a non-object");
+  if (hasSql(source)) {
     const expr = getSql(source);
     const name = expr.alias;
     if (!name) throw new Error("Cannot alias a virtual field without a name");
     return Object.assign(new Field(alias, name, expr), target);
   }
-  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 target2[field] = new Field(
-        alias,
-        field,
-        from ? getSql(from) : void 0
-      );
-    }
-  });
+  const aliased = Object.fromEntries(
+    Object.entries(source).map(([key, value]) => {
+      return [key, new Field(alias, key, getSql(value))];
+    })
+  );
+  return {
+    [internalTarget]: sql.identifier(alias),
+    ...aliased
+  };
 }
 export {
   virtual

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

@@ -1,6 +1,6 @@
 import { type HasSql } from '../Internal.js';
 import type { Either } from '../MetaData.js';
-import type { Query } from '../Query.js';
+import type { SingleQuery } from '../Queries.js';
 import { type Sql } from '../Sql.js';
 import { type Input } from './Input.js';
 export declare const eq: <T>(left: Input<T>, right: Input<T>) => Sql<boolean>;
@@ -19,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: 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 inArray<T>(left: Input<T>, right: SingleQuery<Array<T>, any> | Input<Array<T>>): Sql<boolean>;
+export declare function notInArray<T>(left: Input<T>, right: SingleQuery<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>;
@@ -30,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(query: Query<any, Either>): Sql<boolean>;
+export declare function exists(query: SingleQuery<any, Either>): Sql<boolean>;

package/dist/core/expr/Conditions.js

@@ -1,12 +1,14 @@
 // src/core/expr/Conditions.ts
-import { getQuery, getSql, hasSql } from "../Internal.js";
+import { getQuery, hasSql } 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) => bool(sql`${input(left)} ${sql.unsafe(operator)} ${input(right)}`);
+  return (left, right) => bool(
+    sql`${input(left, right)} ${sql.unsafe(operator)} ${input(right, left)}`
+  );
 }
 var eq = binop("=");
 var ne = binop("<>");
@@ -22,13 +24,13 @@ var arrayContains = binop("@>");
 var arrayContained = binop("<@");
 var arrayOverlaps = binop("&&");
 function and(...conditions) {
-  const inputs = conditions.filter((v) => v !== void 0).map(input);
+  const inputs = conditions.filter((v) => v !== void 0).map((i) => input(i));
   if (inputs.length === 0) return bool(sql`true`);
   if (inputs.length === 1) 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);
+  const inputs = conditions.filter((v) => v !== void 0).map((i) => input(i));
   if (inputs.length === 0) return bool(sql`true`);
   if (inputs.length === 1) return bool(inputs[0]);
   return bool(sql`(${sql.join(inputs, sql` or `)})`);
@@ -37,19 +39,27 @@ function not(condition) {
   return bool(sql`not ${input(condition)}`);
 }
 function inArray(left, right) {
-  const value = (hasSql(right) ? getSql(right).getValue() : void 0) ?? right;
+  const value = hasSql(right) ? void 0 : right;
   if (Array.isArray(value)) {
     if (value.length === 0) return sql`false`;
-    return bool(sql`${input(left)} in (${sql.join(value.map(input), sql`, `)})`);
+    return bool(
+      sql`${input(left)} in (${sql.join(
+        value.map((i) => input(i)),
+        sql`, `
+      )})`
+    );
   }
   return bool(sql`${input(left)} in ${input(right)}`);
 }
 function notInArray(left, right) {
-  const value = (hasSql(right) ? getSql(right).getValue() : void 0) ?? right;
+  const value = hasSql(right) ? void 0 : right;
   if (Array.isArray(value)) {
     if (value.length === 0) return sql`true`;
     return bool(
-      sql`${input(left)} not in (${sql.join(value.map(input), sql`, `)})`
+      sql`${input(left)} not in (${sql.join(
+        value.map((i) => input(i)),
+        sql`, `
+      )})`
     );
   }
   return bool(sql`${input(left)} not in ${input(right)}`);

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

@@ -1,15 +1,17 @@
-import type { DriverSpecs } from '../Driver.js';
-import { internalField, internalSql, type HasSql } from '../Internal.js';
-import { type Sql } from '../Sql.js';
+import { type HasSql, internalField, internalSql } from '../Internal.js';
+import type { SelectionRecord } from '../Selection.js';
+import { type Decoder, type Sql } from '../Sql.js';
 export interface FieldData {
     targetName: string;
     fieldName: string;
+    source: Decoder;
 }
 export declare class Field<Value = unknown, Table extends string = string> implements HasSql<Value> {
     private brand;
     readonly [internalField]: FieldData;
     readonly [internalSql]: Sql<Value>;
-    constructor(targetName: string, fieldName: string, options?: {
-        mapFromDriverValue?(value: unknown, specs: DriverSpecs): Value;
-    });
+    constructor(targetName: string, fieldName: string, source?: Decoder<Value>);
 }
+export type StripFieldMeta<Input> = Input extends HasSql<infer Value> ? HasSql<Value> : Input extends SelectionRecord ? {
+    [Key in keyof Input]: StripFieldMeta<Input[Key]>;
+} : Input;

package/dist/core/expr/Field.js

@@ -4,10 +4,10 @@ import { sql } from "../Sql.js";
 var Field = class {
   [internalField];
   [internalSql];
-  constructor(targetName, fieldName, options = {}) {
-    const field = { targetName, fieldName };
+  constructor(targetName, fieldName, source = {}) {
+    const field = { targetName, fieldName, source };
     this[internalField] = field;
-    const expr = sql.field(field).as(fieldName).mapWith(options);
+    const expr = sql.field(field).as(fieldName).mapWith(source);
     this[internalSql] = expr;
   }
 };

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

@@ -1,19 +1,22 @@
-import { type HasData, type HasSql, internalData, internalSql } from '../Internal.js';
+import { type HasSql, internalData, internalSql } from '../Internal.js';
 import type { QueryMeta } from '../MetaData.js';
+import type { QueryData } from '../Queries.js';
 import type { RowOfRecord } from '../Selection.js';
 import { type Sql } from '../Sql.js';
-import type { Select, SelectBase, SelectData } from '../query/Select.js';
-export interface IncludeData<Meta extends QueryMeta = QueryMeta> extends SelectData<Meta> {
+import type { SelectQuery } from '../query/Query.js';
+import { type Select, type SelectBase } from '../query/Select.js';
+export type IncludeQuery = SelectQuery & {
     first: boolean;
-}
-export declare class Include<Result, Meta extends QueryMeta = QueryMeta> implements HasData<IncludeData<Meta>>, HasSql<Result> {
+};
+export declare class Include<Result, Meta extends QueryMeta = QueryMeta> implements HasSql<Result> {
     #private;
     private brand;
-    readonly [internalData]: IncludeData<Meta>;
-    constructor(data: IncludeData<Meta>);
+    readonly [internalData]: QueryData<Meta> & IncludeQuery;
+    constructor(data: QueryData<Meta> & IncludeQuery);
     get [internalSql](): Sql<Result>;
 }
 export declare function include<Input, Meta extends QueryMeta>(select: Select<Input, Meta>): Include<Array<RowOfRecord<Input>>, Meta>;
 export declare namespace include {
     function one<Input, Meta extends QueryMeta>(select: SelectBase<Input, Meta>): Include<RowOfRecord<Input> | null, Meta>;
 }
+export declare function includeQuery(query: IncludeQuery): Sql;

package/dist/core/expr/Include.js

@@ -1,20 +1,22 @@
 // src/core/expr/Include.ts
-import {
-  getData,
-  internalData,
-  internalSql
-} from "../Internal.js";
+import { getData, internalData, internalSql } from "../Internal.js";
 import { sql } from "../Sql.js";
+import {
+  querySelection,
+  selectQuery
+} from "../query/Select.js";
+import { jsonAggregateArray, jsonArray } from "./Json.js";
 var Include = class {
   [internalData];
   constructor(data) {
     this[internalData] = data;
   }
   #mapFromDriverValue = (value, specs) => {
-    const { select, first } = getData(this);
+    const query = getData(this);
     const parsed = specs.parsesJson ? value : JSON.parse(value);
-    if (first) {
-      const result = parsed ? select.mapRow({ values: parsed, index: 0, specs }) : null;
+    const selected = querySelection(query);
+    if (query.first) {
+      const result = parsed ? selected.mapRow({ values: parsed, index: 0, specs }) : null;
       return result;
     }
     if (!parsed) return [];
@@ -27,12 +29,12 @@ var Include = class {
     for (let i = 0; i < rows.length; i++) {
       ctx.values = rows[i];
       ctx.index = 0;
-      rows[i] = select.mapRow(ctx);
+      rows[i] = selected.mapRow(ctx);
     }
     return rows ?? [];
   };
   get [internalSql]() {
-    return sql.chunk("emitInclude", getData(this)).mapWith({
+    return includeQuery(getData(this)).mapWith({
       mapFromDriverValue: this.#mapFromDriverValue
     });
   }
@@ -42,11 +44,26 @@ function include(select) {
 }
 ((include2) => {
   function one(select) {
-    return new Include({ ...getData(select), first: true });
+    return new Include({
+      ...getData(select),
+      first: true
+    });
   }
   include2.one = one;
 })(include || (include = {}));
+function includeQuery(query) {
+  const { first, limit, offset, orderBy } = query;
+  const wrapQuery = Boolean(limit || offset || orderBy);
+  const innerQuery = selectQuery(query);
+  const inner = wrapQuery ? sql`select * from (${innerQuery})` : innerQuery;
+  const fields = querySelection(query).fieldNames();
+  const subject = jsonArray(
+    ...fields.map((name) => sql`_.${sql.identifier(name)}`)
+  );
+  return sql`(select ${first ? subject : jsonAggregateArray(subject)} from (${inner}) as _)`;
+}
 export {
   Include,
-  include
+  include,
+  includeQuery
 };

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

@@ -1,4 +1,6 @@
+import type { ColumnData } from '../Column.js';
 import { type HasSql } from '../Internal.js';
 import { type Sql } from '../Sql.js';
 export type Input<T = unknown> = HasSql<T> | T;
-export declare function input<T>(value: Input<T>): Sql<T>;
+export declare function input<T>(value: Input<T>, maybeField?: Input<T>): Sql<T>;
+export declare function mapToColumn<T>({ mapToDriverValue }: ColumnData, expr: Input<T>): Sql<T>;