rado 1.2.0 → 1.3.0-preview.0

package/dist/core/Column.d.ts

@@ -1,58 +1,71 @@
 import type { DriverSpecs } from './Driver.js';
-import { internalData } from './Internal.js';
-import { type Sql } from './Sql.js';
 import type { Field, FieldData } from './expr/Field.js';
 import { type Input } from './expr/Input.js';
-export interface ColumnData {
-    type: Sql;
+import { type HasSql, internalData, internalEnum, internalSql } from './Internal.js';
+import { type Sql } from './Sql.js';
+export type ReferenceAction = 'cascade' | 'restrict' | 'no action' | 'set null' | 'set default';
+export interface ReferenceOptions {
+    onDelete?: ReferenceAction;
+    onUpdate?: ReferenceAction;
+}
+export interface BaseColumnData {
+    type: HasSql;
     name?: string;
     json?: boolean;
     primary?: boolean;
     notNull?: boolean;
     isUnique?: boolean;
+    nullsNotDistinct?: boolean;
     autoIncrement?: boolean;
     defaultValue?: Sql;
     references?(): FieldData;
+    referenceOptions?: ReferenceOptions;
     mapFromDriverValue?(value: unknown, specs: DriverSpecs): unknown;
     mapToDriverValue?(value: unknown): unknown;
     $default?(): Sql;
     $onUpdate?(): Sql;
+    readonly [internalEnum]?: unknown;
 }
+export interface ColumnData extends BaseColumnData {
+    type: ColumnType;
+}
+export declare class ColumnType implements HasSql {
+    kind: string;
+    args: Array<Input<unknown>>;
+    [internalSql]: Sql;
+    constructor(kind: string, args: Array<Input<unknown>>, sql?: Sql);
+}
+export type Nullability = [allowsNull: boolean, isRequired: boolean];
 type WithoutNull<Value> = Exclude<Value, null>;
-export declare class Column<Value = unknown> {
+export declare class Column<Value = unknown, Nulls extends Nullability = Nullability> {
     readonly [internalData]: ColumnData;
     constructor(data: ColumnData);
-    notNull(): RequiredColumn<Value>;
-    $defaultFn(value: () => Input<WithoutNull<Value>>): Column<WithoutNull<Value>>;
-    $default(value: Input<WithoutNull<Value>> | (() => Input<WithoutNull<Value>>)): Column<WithoutNull<Value>>;
-    $onUpdateFn(fn: () => Input<Value>): Column<Value>;
-    $onUpdate(fn: () => Input<Value>): Column<Value>;
-    default(value: Input<WithoutNull<Value>>): Column<WithoutNull<Value>>;
-    defaultNow(): Column<WithoutNull<Value>>;
+    notNull(): Column<Value, [false, Nulls[1]]>;
+    $defaultFn(value: () => Input<Value>): Column<Value, [Nulls[0], false]>;
+    $default(value: Input<Value> | (() => Input<Value>)): Column<Value, [Nulls[0], false]>;
+    $onUpdateFn(fn: () => Input<Value>): Column<Value, Nulls>;
+    $onUpdate(fn: () => Input<Value>): Column<Value, Nulls>;
+    default(value: Input<Value>): Column<Value, [Nulls[0], false]>;
+    defaultNow(): Column<WithoutNull<Value>, [Nulls[0], false]>;
     primaryKey(options?: {
         autoIncrement: boolean;
-    }): Column<WithoutNull<Value>>;
-    unique(name?: string): Column<Value>;
-    references(foreignField: Field | (() => Field)): Column<Value>;
-    $type<T>(): Column<null extends Value ? T | null : T>;
+    }): Column<Value, [false, false]>;
+    unique(name?: string): Column<Value, Nulls>;
+    references(foreignField: Field | (() => Field), options?: ReferenceOptions): Column<Value, Nulls>;
+    $type<T>(): Column<T, Nulls>;
 }
-export declare class JsonColumn<Value = unknown> extends Column<Value> {
+export declare class JsonColumn<Value, Meta extends Nullability = Nullability> extends Column<Value, Meta> {
     private brand;
     constructor(data: ColumnData);
 }
-declare const required: unique symbol;
-export interface RequiredColumn<Value = unknown> extends Column<WithoutNull<Value>> {
-    [required]: true;
-}
 export interface Columns {
-    <T>(data: ColumnData): Column<T>;
-    [key: string]: (...args: Array<Input<any>>) => Sql<any>;
+    [key: string]: (...args: Array<Input<any>>) => ColumnType;
 }
 export declare const column: Columns;
-export type ColumnArguments<Options> = [name?: string] | [options: Options] | [name: string, options: Options];
+export type ColumnArguments<Options> = [name?: string] | [options: Options] | [name: string | undefined, options: Options];
 export declare function columnConfig<Options>(args: ColumnArguments<Options>): {
     name: string | undefined;
     options: Options | undefined;
 };
-export declare function formatColumn(column: ColumnData): Sql;
+export declare function formatColumn(column: BaseColumnData): Sql;
 export {};

package/dist/core/Column.js

@@ -1,8 +1,26 @@
 // src/core/Column.ts
-import { getData, getField, internalData } from "./Internal.js";
-import { sql } from "./Sql.js";
 import { callFunction } from "./expr/Functions.js";
 import { input, mapToColumn } from "./expr/Input.js";
+import {
+  getData,
+  getField,
+  internalData,
+  internalSql
+} from "./Internal.js";
+import { sql } from "./Sql.js";
+function formatType(kind, args) {
+  return args.length === 0 ? sql.unsafe(kind) : sql`${sql.unsafe(kind)}(${sql.join(args.map(sql.inline), sql`, `)})`;
+}
+var ColumnType = class {
+  constructor(kind, args, sql2 = formatType(kind, args)) {
+    this.kind = kind;
+    this.args = args;
+    this[internalSql] = sql2;
+  }
+  kind;
+  args;
+  [internalSql];
+};
 var Column = class _Column {
   [internalData];
   constructor(data) {
@@ -20,7 +38,10 @@ var Column = class _Column {
   $default(value) {
     return new _Column({
       ...getData(this),
-      $default: () => mapToColumn(getData(this), value instanceof Function ? value() : value)
+      $default: () => mapToColumn(
+        getData(this),
+        typeof value === "function" ? value() : value
+      )
     });
   }
   $onUpdateFn(fn) {
@@ -50,14 +71,15 @@ var Column = class _Column {
   unique(name) {
     return new _Column({ ...getData(this), isUnique: true });
   }
-  references(foreignField) {
+  references(foreignField, options) {
     return new _Column({
       ...getData(this),
       references() {
         return getField(
           typeof foreignField === "function" ? foreignField() : foreignField
         );
-      }
+      },
+      referenceOptions: options
     });
   }
   $type() {
@@ -69,50 +91,57 @@ var JsonColumn = class extends Column {
     super({ ...data, json: true });
   }
 };
-function createColumn(data) {
-  return new Column(data);
-}
-var column = new Proxy(createColumn, {
-  get(target, method) {
-    return target[method] ??= (...args) => {
-      while (args.length > 0)
-        if (args.at(-1) === void 0) args.pop();
-        else break;
-      if (args.length === 0) return sql.unsafe(method);
-      return sql`${sql.unsafe(method)}(${sql.join(
-        args.map(sql.inline),
-        sql`, `
-      )})`;
-    };
+var column = new Proxy(
+  {},
+  {
+    get(target, method) {
+      return target[method] ??= (...args) => {
+        while (args.length > 0)
+          if (args.at(-1) === void 0) args.pop();
+          else break;
+        return new ColumnType(method, args);
+      };
+    }
   }
-});
+);
 function columnConfig(args) {
+  if (args.length > 1)
+    return { name: args[0], options: args[1] };
   if (typeof args[0] === "string")
     return { name: args[0], options: args[1] };
   return { name: void 0, options: args[0] };
 }
-function formatReferences(fields) {
-  return callFunction(
-    sql.identifier(fields[0].targetName),
-    fields.map((field) => sql.identifier(field.fieldName))
+function formatReferences(fields, options = {}) {
+  return sql.query(
+    callFunction(
+      sql.identifier(fields[0].targetName),
+      fields.map((field) => sql.identifier(field.fieldName))
+    ),
+    {
+      onDelete: options.onDelete && sql.unsafe(options.onDelete),
+      onUpdate: options.onUpdate && sql.unsafe(options.onUpdate)
+    }
   );
 }
 function formatColumn(column2) {
-  const references = column2.references && sql`references ${formatReferences([column2.references()])}`;
   return sql.query(
     column2.type,
     {
       primaryKey: column2.primary,
       notNull: column2.notNull,
       unique: column2.isUnique,
+      nullsNotDistinct: column2.nullsNotDistinct,
       autoincrement: column2.autoIncrement
     },
     column2.defaultValue !== void 0 ? sql`default (${column2.defaultValue})`.inlineValues() : void 0,
-    references
+    {
+      references: column2.references && formatReferences([column2.references()], column2.referenceOptions)
+    }
   );
 }
 export {
   Column,
+  ColumnType,
   JsonColumn,
   column,
   columnConfig,

package/dist/core/Constraint.d.ts

@@ -1,6 +1,6 @@
+import type { Field, FieldData } from './expr/Field.js';
 import { type HasConstraint, type HasData, internalConstraint, internalData } from './Internal.js';
 import { type Sql } from './Sql.js';
-import type { Field, FieldData } from './expr/Field.js';
 export interface ConstraintData {
     name?: string;
 }
@@ -46,6 +46,7 @@ export declare class ForeignKeyConstraint<TableName extends string = string> imp
 export declare function foreignKey<TableName extends string = string>(options: {
     name?: string;
     columns: Array<Field<unknown, TableName>>;
+    foreignColumns?: Array<Field<unknown, string>>;
 }): ForeignKeyConstraint<TableName>;
 export declare function foreignKey<TableName extends string = string>(...fields: Array<Field<unknown, TableName>>): ForeignKeyConstraint<TableName>;
 export type Constraint = UniqueConstraint | PrimaryKeyConstraint | ForeignKeyConstraint;

package/dist/core/Constraint.js

@@ -38,6 +38,7 @@ var PrimaryKeyConstraint = class {
     this.data = data;
     this[internalData] = data;
   }
+  data;
   [internalData];
   get [internalConstraint]() {
     const { fields } = getData(this);
@@ -82,7 +83,7 @@ function foreignKey(...args) {
     return new ForeignKeyConstraint({
       name: args[0].name,
       fields: args[0].columns.map(getField),
-      references: []
+      references: args[0].foreignColumns?.map(getField) ?? []
     });
   return new ForeignKeyConstraint({
     fields: args.map(getField),

package/dist/core/Database.d.ts

@@ -2,13 +2,13 @@ import { Builder } from './Builder.js';
 import type { Dialect } from './Dialect.js';
 import type { Diff } from './Diff.js';
 import type { Driver } from './Driver.js';
-import { type HasQuery, type HasResolver, type HasSql, type HasTable, internalResolver } from './Internal.js';
+import { type HasCreate, type HasDrop, type HasQuery, type HasResolver, type HasSql, type HasTarget, internalResolver } from './Internal.js';
 import type { Async, Deliver, Either, QueryDialect, QueryMeta, Sync } from './MetaData.js';
 import { BatchQuery } from './Queries.js';
+import type { SelectFirst } from './query/Select.js';
 import { Resolver } from './Resolver.js';
 import { type Sql } from './Sql.js';
 import type { Table } from './Table.js';
-import type { SelectFirst } from './query/Select.js';
 export declare class Database<Meta extends QueryMeta = Either> extends Builder<Meta> implements HasResolver<Meta> {
     driver: Driver;
     dialect: Dialect;
@@ -19,8 +19,8 @@ export declare class Database<Meta extends QueryMeta = Either> extends Builder<M
     close(this: Database<Sync>): void;
     [Symbol.dispose](this: Database<Sync>): void;
     [Symbol.asyncDispose](this: Database<Async>): Promise<void>;
-    create(...tables: Array<HasTable>): BatchQuery<unknown, Meta>;
-    drop(...tables: Array<HasTable>): BatchQuery<unknown, Meta>;
+    create(...createables: Array<HasCreate>): BatchQuery<unknown, Meta>;
+    drop(...droppables: Array<HasDrop>): BatchQuery<unknown, Meta>;
     run(input: HasSql): Deliver<Meta, void>;
     get<Result extends Array<unknown>>(input: HasQuery<Result>): Deliver<Meta, Result[number]>;
     get<Result>(input: HasSql<Result>): Deliver<Meta, Result>;
@@ -28,6 +28,7 @@ export declare class Database<Meta extends QueryMeta = Either> extends Builder<M
     migrate(...tables: Array<Table>): Deliver<Meta, void>;
     batch<Queries extends Array<HasSql | HasQuery>>(queries: Queries): BatchQuery<unknown, Meta>;
     execute(input: HasSql): Deliver<Meta, void>;
+    refreshMaterializedView(view: HasTarget): Deliver<Meta, void>;
     transaction<T>(this: Database<Sync>, run: (tx: Transaction<Meta>) => T, options?: TransactionOptions[Meta['dialect']]): T;
     transaction<T>(this: Database<Async>, run: (tx: Transaction<Meta>) => Promise<T>, options?: TransactionOptions[Meta['dialect']]): Promise<T>;
     transaction<T>(run: (tx: Transaction<Meta>) => T | Promise<T>, options?: TransactionOptions[Meta['dialect']]): Deliver<Meta, T>;

package/dist/core/Database.js

@@ -1,15 +1,17 @@
 // src/core/Database.ts
 import { txGenerator } from "../universal.js";
 import { Builder } from "./Builder.js";
+import { count } from "./expr/Aggregate.js";
 import {
+  getCreate,
+  getDrop,
   getResolver,
-  getTable,
+  getSql,
   internalResolver
 } from "./Internal.js";
 import { BatchQuery } from "./Queries.js";
 import { Resolver } from "./Resolver.js";
 import { sql } from "./Sql.js";
-import { count } from "./expr/Aggregate.js";
 var Database = class extends Builder {
   driver;
   dialect;
@@ -32,17 +34,11 @@ var Database = class extends Builder {
   async [Symbol.asyncDispose]() {
     return this.close();
   }
-  create(...tables) {
-    return new BatchQuery(
-      getResolver(this),
-      tables.flatMap((table) => getTable(table).create())
-    );
+  create(...createables) {
+    return new BatchQuery(getResolver(this), createables.flatMap(getCreate));
   }
-  drop(...tables) {
-    return new BatchQuery(
-      getResolver(this),
-      tables.map((table) => getTable(table).drop())
-    );
+  drop(...droppables) {
+    return new BatchQuery(getResolver(this), droppables.flatMap(getDrop));
   }
   run(input) {
     const sql2 = this.dialect.inline(input);
@@ -71,10 +67,14 @@ var Database = class extends Builder {
     return new BatchQuery(getResolver(this), queries);
   }
   execute(input) {
-    const emitter = this.dialect.emit(input);
+    const inner = getSql(input);
+    const emitter = this.dialect.emit(inner.inlineValues());
     if (emitter.hasParams) throw new Error("Query has parameters");
     return this.driver.exec(emitter.sql);
   }
+  refreshMaterializedView(view) {
+    return this.execute(sql`refresh materialized view ${view}`);
+  }
   transaction(run, options = {}) {
     return this.driver.transaction(
       (inner) => {
@@ -93,6 +93,7 @@ var Rollback = class extends Error {
     super("Rollback");
     this.data = data;
   }
+  data;
 };
 var Transaction = class extends Database {
   rollback(data) {

package/dist/core/Emitter.d.ts

@@ -1,9 +1,9 @@
+import type { FieldData } from './expr/Field.js';
+import type { JsonPath } from './expr/Json.js';
 import { type HasSql } from './Internal.js';
 import type { Runtime } from './MetaData.js';
 import { type Param } from './Param.js';
 import { Sql } from './Sql.js';
-import type { FieldData } from './expr/Field.js';
-import type { JsonPath } from './expr/Json.js';
 export declare abstract class Emitter {
     #private;
     sql: string;

package/dist/core/Index.d.ts

@@ -1,6 +1,6 @@
+import type { Field } from './expr/Field.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 {
     fields: Array<HasSql>;
     concurrently?: boolean;

package/dist/core/Internal.d.ts

@@ -1,9 +1,9 @@
+import type { FieldData } from './expr/Field.js';
 import type { QueryMeta } from './MetaData.js';
 import type { Resolver } from './Resolver.js';
 import type { Selection } from './Selection.js';
 import type { Sql } from './Sql.js';
 import type { TableApi, TableDefinition } from './Table.js';
-import type { FieldData } from './expr/Field.js';
 export declare const internalData: unique symbol;
 export declare const internalSql: unique symbol;
 export declare const internalSelection: unique symbol;
@@ -15,6 +15,9 @@ export declare const internalField: unique symbol;
 export declare const internalResolver: unique symbol;
 export declare const internalConstraint: unique symbol;
 export declare const internalInclude: unique symbol;
+export declare const internalEnum: unique symbol;
+export declare const internalCreate: unique symbol;
+export declare const internalDrop: unique symbol;
 export declare class HasData<Data> {
     get [internalData](): Data;
 }
@@ -26,7 +29,6 @@ export declare class HasSelection {
 }
 export declare class HasTarget<Name extends string = string> {
     get [internalTarget](): Sql;
-    private brand?;
 }
 export declare class HasQuery<Result = unknown> {
     get [internalQuery](): Sql<Result>;
@@ -46,6 +48,15 @@ export declare class HasResolver<Meta extends QueryMeta = QueryMeta> {
 export declare class HasConstraint {
     get [internalConstraint](): Sql;
 }
+export declare class HasEnum<EnumData> {
+    get [internalEnum](): EnumData;
+}
+export interface HasCreate {
+    readonly [internalCreate]: Array<Sql>;
+}
+export interface HasDrop {
+    readonly [internalDrop]: Array<Sql>;
+}
 export declare const hasData: <Data>(obj: object) => obj is HasData<Data>;
 export declare const getData: <Data>(obj: HasData<Data>) => Data;
 export declare const hasSql: <Value>(obj: object) => obj is HasSql<Value>;
@@ -66,3 +77,9 @@ export declare const hasResolver: <Meta extends QueryMeta>(obj: object) => obj i
 export declare const getResolver: <Meta extends QueryMeta>(obj: HasResolver<Meta>) => Resolver<Meta>;
 export declare const hasConstraint: (obj: object) => obj is HasConstraint;
 export declare const getConstraint: (obj: HasConstraint) => Sql<unknown>;
+export declare const hasEnum: <EnumData>(obj: object) => obj is HasEnum<EnumData>;
+export declare const getEnum: <EnumData>(obj: HasEnum<EnumData>) => EnumData;
+export declare const hasCreate: (obj: object) => obj is HasCreate;
+export declare const getCreate: (obj: HasCreate) => Sql<unknown>[];
+export declare const hasDrop: (obj: object) => obj is HasDrop;
+export declare const getDrop: (obj: HasDrop) => Sql<unknown>[];

package/dist/core/Internal.js

@@ -1,15 +1,18 @@
 // src/core/Internal.ts
-var internalData = Symbol();
-var internalSql = Symbol();
-var internalSelection = Symbol();
-var internalTarget = Symbol();
-var internalQuery = Symbol();
-var internalBatch = Symbol();
-var internalTable = Symbol();
-var internalField = Symbol();
-var internalResolver = Symbol();
-var internalConstraint = Symbol();
-var internalInclude = Symbol();
+var internalData = /* @__PURE__ */ Symbol();
+var internalSql = /* @__PURE__ */ Symbol();
+var internalSelection = /* @__PURE__ */ Symbol();
+var internalTarget = /* @__PURE__ */ Symbol();
+var internalQuery = /* @__PURE__ */ Symbol();
+var internalBatch = /* @__PURE__ */ Symbol();
+var internalTable = /* @__PURE__ */ Symbol();
+var internalField = /* @__PURE__ */ Symbol();
+var internalResolver = /* @__PURE__ */ Symbol();
+var internalConstraint = /* @__PURE__ */ Symbol();
+var internalInclude = /* @__PURE__ */ Symbol();
+var internalEnum = /* @__PURE__ */ Symbol();
+var internalCreate = /* @__PURE__ */ Symbol();
+var internalDrop = /* @__PURE__ */ Symbol();
 var hasData = (obj) => internalData in obj;
 var getData = (obj) => obj[internalData];
 var hasSql = (obj) => internalSql in obj;
@@ -30,10 +33,19 @@ var hasResolver = (obj) => internalResolver in obj;
 var getResolver = (obj) => obj[internalResolver];
 var hasConstraint = (obj) => internalConstraint in obj;
 var getConstraint = (obj) => obj[internalConstraint];
+var hasEnum = (obj) => internalEnum in obj;
+var getEnum = (obj) => obj[internalEnum];
+var hasCreate = (obj) => internalCreate in obj;
+var getCreate = (obj) => obj[internalCreate];
+var hasDrop = (obj) => internalDrop in obj;
+var getDrop = (obj) => obj[internalDrop];
 export {
   getBatch,
   getConstraint,
+  getCreate,
   getData,
+  getDrop,
+  getEnum,
   getField,
   getQuery,
   getResolver,
@@ -43,7 +55,10 @@ export {
   getTarget,
   hasBatch,
   hasConstraint,
+  hasCreate,
   hasData,
+  hasDrop,
+  hasEnum,
   hasField,
   hasQuery,
   hasResolver,
@@ -53,7 +68,10 @@ export {
   hasTarget,
   internalBatch,
   internalConstraint,
+  internalCreate,
   internalData,
+  internalDrop,
+  internalEnum,
   internalField,
   internalInclude,
   internalQuery,

package/dist/core/Param.js

@@ -3,11 +3,13 @@ var NamedParam = class {
   constructor(name) {
     this.name = name;
   }
+  name;
 };
 var ValueParam = class {
   constructor(value) {
     this.value = value;
   }
+  value;
 };
 export {
   NamedParam,

package/dist/core/Queries.d.ts

@@ -29,6 +29,7 @@ export declare abstract class SingleQuery<Result, Meta extends QueryMeta> extend
     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>;
+    execute(inputs?: Record<string, unknown>, db?: HasResolver): Promise<Result>;
     prepare<Inputs extends Record<string, unknown>>(name?: string): PreparedQuery<Result, Inputs, Meta>;
     toSQL(db?: HasResolver): {
         sql: string;

package/dist/core/Queries.js

@@ -25,7 +25,6 @@ var Executable = class {
   run() {
     return this.#execute();
   }
-  // biome-ignore lint/suspicious/noThenProperty:
   async then(onfulfilled, onrejected) {
     try {
       const result = await this.#execute();
@@ -82,6 +81,17 @@ var SingleQuery = class extends Executable {
   run(db) {
     return this.#exec("run", db);
   }
+  async execute(inputs, db) {
+    const data = getData(this);
+    const resolver = db ? getResolver(db) : data.resolver;
+    if (!resolver) throw new Error("Query has no resolver");
+    const prepared = resolver.prepare(this, "");
+    try {
+      return await prepared.execute(inputs);
+    } finally {
+      prepared.free();
+    }
+  }
   prepare(name) {
     return getData(this).resolver.prepare(this, name);
   }

package/dist/core/Resolver.js

@@ -54,9 +54,9 @@ var Batch = class {
       if (!mapRow) continue;
       const rows = results[i];
       for (let j = 0; j < results[i].length; j++) {
-        ctx.values = rows[i];
+        ctx.values = rows[j];
         ctx.index = 0;
-        rows[i] = mapRow(ctx);
+        rows[j] = mapRow(ctx);
       }
     }
     return results;

package/dist/core/Schema.d.ts

@@ -1,7 +1,5 @@
 import { type Table, type TableConfig, type TableDefinition } from './Table.js';
-type Prefix<SchemaName extends string, TableName extends string> = `${SchemaName}.${TableName}`;
 export interface Schema<SchemaName extends string> {
-    table<Definition extends TableDefinition, TableName extends string>(tableName: TableName, columns: Definition, config?: (self: Table<Definition>) => TableConfig<Prefix<SchemaName, TableName>>): Table<Definition, Prefix<SchemaName, TableName>>;
+    table<Definition extends TableDefinition, TableName extends string>(tableName: TableName, columns: Definition, config?: (self: Table<Definition>) => TableConfig<TableName>): Table<Definition, TableName>;
 }
 export declare function schema<SchemaName extends string>(schemaName: SchemaName): Schema<SchemaName>;
-export {};

package/dist/core/Selection.d.ts

@@ -1,10 +1,11 @@
 import type { DriverSpecs } from './Driver.js';
+import type { Include } from './expr/Include.js';
 import { type HasSql, type HasTable, type HasTarget, internalSql } from './Internal.js';
+import type { JoinOp } from './query/Query.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';
+import { type VirtualTarget } from './Virtual.js';
 declare const nullable: unique symbol;
 export interface SelectionRecord extends Record<string, SelectionInput> {
 }
@@ -18,7 +19,7 @@ export type SelectionInput = HasSql | HasTable | HasTarget | SelectionRecord | I
 export type RowOfRecord<Input> = Expand<{
     [Key in keyof Input as Key extends string ? Key : never]: SelectionRow<Input[Key]>;
 }>;
-export type SelectionRow<Input> = Input extends HasSql<infer Value> ? Value : Input extends IsNullable ? RowOfRecord<Input> | null : Input extends SelectionRecord ? RowOfRecord<Input> : Input extends Table<infer Definition> ? TableRow<Definition> : never;
+export type SelectionRow<Input> = Input extends HasSql<infer Value> ? Value : Input extends IsNullable ? RowOfRecord<Input> | null : Input extends Table<infer Definition> ? TableRow<Definition> : Input extends object ? RowOfRecord<Input> : never;
 export interface MapRowContext {
     values: Array<unknown>;
     index: number;
@@ -30,8 +31,9 @@ export declare class Selection implements HasSql {
     nullable: Set<string>;
     mapRow: (ctx: MapRowContext) => unknown;
     constructor(input: SelectionInput, nullable?: Set<string>);
-    makeVirtual<Input>(name: string): Input & HasTarget;
+    makeVirtual<Input>(name: string): VirtualTarget<Input>;
     fieldNames(): Array<string>;
+    aliasOf(input: HasSql): string | undefined;
     get [internalSql](): Sql;
     join(right: HasTarget | Sql, operator: JoinOp): Selection;
 }
@@ -45,5 +47,8 @@ export declare class JoinSelection extends Selection {
     constructor(tables: Array<HasTable>, nullable: Set<string>);
     join(right: HasTarget | Sql, operator: JoinOp): Selection;
 }
+export declare class StarSelection extends Selection {
+    get [internalSql](): Sql;
+}
 export declare function selection(input: SelectionInput): Selection;
 export {};