kysely-rizzolver 0.0.2 → 0.0.3

package/dist/types/kysely-rizzolver.d.ts

@@ -1,10 +1,17 @@
+import type { Kysely } from 'kysely';
 import { type FetchResultFactory } from './fetch-result-factory.js';
+import { FkGatherResultFactory } from './fk-gather-result-factory.js';
+import { DBWithFk, GatherOpts, GatherWhereExpression, MAX_FK_GATHER_DEPTH, NoNullGatherOpts, ValidFkDepth } from './fks.js';
+import { type ModelCollection } from './model-collection.js';
 import { type QueryBuilder } from './query-builder.js';
 import { type Selector } from './selector.js';
-import { type ModelCollection } from './model-collection.js';
-export interface KyselyRizzolverBase<DB, T extends Record<keyof DB & string, readonly string[]>> {
-    readonly fields: T;
-    readonly fetches: FetchResultFactory<DB>;
+import { WithMandatory } from './type-helpers.js';
+export interface KyselyRizzolverBase<DB, T extends Record<keyof DB & string, readonly string[]>, FKDefs extends KyselyRizzolverFKs<DB>> {
+    readonly _types: Readonly<{
+        fields: T;
+        fkDefs: FKDefs;
+        dbfk: DBWithFk<DB, FKDefs>;
+    }>;
 }
 /**
  * A {@link KyselyRizzolver} is a class that is used to define the structure of
@@ -17,14 +24,16 @@ export interface KyselyRizzolverBase<DB, T extends Record<keyof DB & string, rea
  * {@link KyselyRizzolver.builder|.builderForSchema()} or
  * {@link KyselyRizzolver.builderNoSchema|.builderNoSchema()}.
  */
-export declare class KyselyRizzolver<DB, T extends Record<keyof DB & string, readonly string[]>> implements KyselyRizzolverBase<DB, T> {
-    readonly fields: T;
-    readonly fetches: FetchResultFactory<DB>;
-    constructor(fields: T);
+export declare class KyselyRizzolver<DB, T extends Record<keyof DB & string, readonly string[]>, FKDefs extends KyselyRizzolverFKs<DB>, DefaultGatherDepth extends ValidFkDepth = typeof MAX_FK_GATHER_DEPTH> implements KyselyRizzolverBase<DB, T, FKDefs> {
+    readonly _types: KyselyRizzolverBase<DB, T, FKDefs>['_types'];
+    readonly fetchObjs: FetchResultFactory<DB>;
+    readonly gatherObjs: FkGatherResultFactory<DB, FKDefs>;
+    readonly defaultGatherDepth: DefaultGatherDepth;
+    constructor(fields: T, fks: FKDefs, defaultGatherDepth?: DefaultGatherDepth);
     /**
      * Intantiates a new {@link Selector} for the given table.
      */
-    newSelector<Table extends keyof DB & string, Alias extends string>(table: Table, alias: Alias): Selector<this, Table, Alias, AllTableFields<this, Table>>;
+    newSelector<Table extends keyof DB & string, Alias extends string>(table: Table, alias: Alias): Selector<this, Table, Alias, KyAllTableFields<this, Table>>;
     /**
      * Instantiates a new {@link QueryBuilder}.
      */
@@ -33,19 +42,25 @@ export declare class KyselyRizzolver<DB, T extends Record<keyof DB & string, rea
      * Instantiates a new {@link ModelCollection}.
      */
     newModelCollection(): ModelCollection<DB>;
+    gatherOne<Table extends keyof DB & string, Opts extends WithMandatory<GatherOpts<DB, ValidFkDepth>, 'depth'>>(db: Kysely<DB>, table: Table, where: GatherWhereExpression<DB, Table>, opts: Opts): Promise<ReturnType<typeof this.gatherObjs.newGatherOne<Table, Opts['depth']>>>;
+    gatherOne<Table extends keyof DB & string>(db: Kysely<DB>, table: Table, where: GatherWhereExpression<DB, Table>, opts?: Omit<GatherOpts<DB, any>, 'depth'>): Promise<ReturnType<typeof this.gatherObjs.newGatherOne<Table, DefaultGatherDepth>>>;
+    gatherOneX<Table extends keyof DB & string, Opts extends WithMandatory<GatherOpts<DB, ValidFkDepth>, 'depth'>>(db: Kysely<DB>, table: Table, where: GatherWhereExpression<DB, Table>, opts: Opts): Promise<ReturnType<typeof this.gatherObjs.newGatherOneX<Table, Opts['depth']>>>;
+    gatherOneX<Table extends keyof DB & string>(db: Kysely<DB>, table: Table, where: GatherWhereExpression<DB, Table>, opts?: Omit<GatherOpts<DB, any>, 'depth'>): Promise<ReturnType<typeof this.gatherObjs.newGatherOneX<Table, DefaultGatherDepth>>>;
+    gatherSome<Table extends keyof DB & string, Opts extends WithMandatory<NoNullGatherOpts<DB, ValidFkDepth>, 'depth'>>(db: Kysely<DB>, table: Table, where: GatherWhereExpression<DB, Table>, opts: Opts): Promise<ReturnType<typeof this.gatherObjs.newGatherSome<Table, Opts['depth']>>>;
+    gatherSome<Table extends keyof DB & string>(db: Kysely<DB>, table: Table, where: GatherWhereExpression<DB, Table>, opts?: Omit<NoNullGatherOpts<DB, any>, 'depth'>): Promise<ReturnType<typeof this.gatherObjs.newGatherSome<Table, DefaultGatherDepth>>>;
     /**
      * Starts building a new {@link KyselyRizzolver} using a builder pattern for
      * a schema.
      *
-     * Call {@link KyselyRizzolverBuilderForSchema.table|.table()} for each
+     * Call {@link KyselyRizzolverBuilder.table|.table()} for each
      * table that exists on the `DB` type parameter with all of their column
      * names as a const array. After all tables have been added, call
-     * {@link KyselyRizzolverBuilderForSchema.build|.build()} to get a new
+     * {@link KyselyRizzolverBuilder.build|.build()} to get a new
      * {@link KyselyRizzolver} instance.
      *
      * Example:
      * ```
-     * const rizzolver = KyselyRizzolver.builderForSchema<DB>()
+     * const rizzolver = KyselyRizzolver.builder<DB>()
      *   .table('user', ['id', 'name', 'email'] as const)
      *   .table('post', ['id', 'title', 'content', 'authorId'] as const)
      *   .build();
@@ -53,86 +68,50 @@ export declare class KyselyRizzolver<DB, T extends Record<keyof DB & string, rea
      *
      * Note: The `as const` assertion is necessary for correct type inference.
      */
-    static builderForSchema<DB>(): KyselyRizzolverBuilderForSchema<DB, {}>;
-    /**
-     * Starts building a new {@link KyselyRizzolver} using a builder pattern
-     * without a schema.
-     *
-     * Call {@link KyselyRizzolverBuilderNoSchema.table|.table()} for each
-     * table with all of their column names as a const array.
-     *
-     * Example:
-     * ```
-     * const rizzolver = KyselyRizzolver.builder()
-     *     .table('user', ['id', 'name', 'email'] as const) // note `as const` is necessary
-     *     .table('post', ['id', 'title', 'content', 'authorId'] as const)
-     *     .build();
-     * ```
-     *
-     * Since this version of builder is schemaless, it cannot infer the value
-     * types for the columns. The `user` type will be `{ id: unknown, name:
-     * unknown, email: unknown }`.
-     *
-     * You may call
-     * {@link KyselyRizzolverBuilderNoSchema.asModel|.asModel\<M\>()}
-     * immediately after the .table() call to provide the types, where `M` is an
-     * type like `{ column1: type1, column2: type2, ... }`.
-     *
-     * Example:
-     * ```
-     * const rizzolver = KyselyRizzolver.builder()
-     *     .table('user', ['id', 'name', 'email'] as const)
-     *     .asModel<{id: number, name: string, email: string}>()
-     *     .table('post', ['id', 'title', 'content', 'authorId'] as const)
-     *     .asModel<{id: number, title: string, content: string, authorId: number}>()
-     *     .build();
-     * ```
-     *
-     * p.s. if your .table() and .asModel() columns differ, it will let you know
-     * at compile time ;)
-     *
-     * Once all tables have been added, call
-     * {@link KyselyRizzolverBuilderNoSchema.build|.build()} to get a new
-     * {@link KyselyRizzolver} instance.
-     */
-    static builderNoSchema(): KyselyRizzolverBuilderNoSchema<{}, null>;
+    static builder<DB>(): import("./kysely-rizzolver-builder.js").KyselyRizzolverBuilder<DB, {}, 3>;
 }
-export type KyselyRizzolverBuilderForSchema<DB, T extends Partial<Record<keyof DB & string, readonly string[]>>> = {
-    table<K extends Exclude<keyof DB & string, keyof T>, U extends readonly (keyof DB[K])[]>(name: K, fields: U & ([keyof DB[K]] extends [U[number]] ? unknown : `Missing key: ${Exclude<keyof DB[K] & string, U[number]>}`)): KyselyRizzolverBuilderForSchema<DB, T & {
-        [key in K]: U;
-    }>;
-    build(): T extends Record<keyof DB & string, readonly string[]> ? KyselyRizzolver<DB, T> : never;
-};
-export type KyselyRizzolverBuilderNoSchema<T extends Record<string, {
-    model: any;
-    columns: readonly string[];
-}>, Last extends keyof T | null> = {
-    table<K extends string, U extends readonly string[]>(name: K, fields: U): KyselyRizzolverBuilderNoSchema<T & {
-        [k in K]: {
-            model: Record<U[number], unknown>;
-            columns: U;
-        };
-    }, K>;
-    asModel<M>(): Last extends keyof T ? keyof M extends T[Last]['columns'][number] ? T[Last]['columns'][number] extends keyof M ? KyselyRizzolverBuilderNoSchema<T & {
-        [k in Last]: {
-            model: M;
-            columns: T[k]['columns'];
+/**
+ * The shape of the foreign key definitions on a {@link KyselyRizzolverBase}.
+ */
+export type KyselyRizzolverFKs<DB> = {
+    [table in keyof DB & string]?: {
+        [fkName: string]: {
+            myField: string;
+            otherTable: keyof DB & string;
+            otherField: string;
+            isNullable: boolean;
         };
-    }, never> : `column '${Exclude<T[Last]['columns'][number], keyof M & string>}' defined in table() but missing from asModel()` : `column '${Exclude<keyof M & string, T[Last]['columns'][number]>}' defined in asModel() but missing from table()` : `asModel() must be called after table()`;
-    build(): KyselyRizzolver<{
-        [k in keyof T]: T[k]['model'];
-    }, {
-        [k in keyof T]: T[k]['columns'];
-    }>;
+    };
 };
-export type KyDB<KY extends KyselyRizzolverBase<any, any>> = KY extends KyselyRizzolverBase<infer DB, any> ? DB : never;
-export type TableName<T extends KyselyRizzolverBase<any, any>> = keyof KyDB<T> & string;
+/**
+ * Extracts the `DB` type from a {@link KyselyRizzolverBase}.
+ */
+export type KyDB<KY extends KyselyRizzolverBase<any, any, any>> = KY extends KyselyRizzolverBase<infer DB, any, any> ? DB : never;
+/**
+ * Variant of {@link TableName} that takes a {@link KyselyRizzolverBase} instead
+ * of a `DB` type.
+ */
+export type KyTableName<T extends KyselyRizzolverBase<any, any, any>> = keyof KyDB<T> & string;
+/**
+ * Variant of {@link AnyTableField} that takes a {@link KyselyRizzolverBase}
+ * instead of a `DB` type.
+ */
+export type KyAnyTableField<KY extends KyselyRizzolverBase<any, any, any>, Table extends KyTableName<KY>> = keyof KyDB<KY>[Table] & string;
+/**
+ * Variant of {@link AllTableFields} that takes a {@link KyselyRizzolverBase}
+ * instead of a `DB` type.
+ */
+export type KyAllTableFields<KY extends KyselyRizzolverBase<any, any, any>, Table extends KyTableName<KY>> = KY extends KyselyRizzolverBase<any, infer T, any> ? T[Table] extends infer U ? U extends readonly KyAnyTableField<KY, Table>[] ? U : never : never : never;
+/**
+ * A union of all the known table names of a database.
+ */
+export type TableName<DB> = keyof DB & string;
 /**
  * A union of all the known fields of a table.
  */
-export type AnyTableField<KY extends KyselyRizzolverBase<any, any>, Table extends TableName<KY>> = keyof KyDB<KY>[Table] & string;
+export type AnyTableField<DB, Table extends TableName<DB>> = keyof DB[Table] & string;
 /**
  * An array of all the known fields of a table, in a type that is compatible
  * with that table's ${@link Selectable} type.
  */
-export type AllTableFields<KY extends KyselyRizzolverBase<any, any>, Table extends TableName<KY>> = KY extends KyselyRizzolverBase<any, infer T> ? T[Table] extends infer U ? U extends readonly AnyTableField<KY, Table>[] ? U : never : never : never;
+export type AllTableFields<DB, Table extends TableName<DB>> = AnyTableField<DB, Table>[];

package/dist/types/model-collection.d.ts

@@ -17,7 +17,11 @@ import type { Selectable } from 'kysely';
  */
 export type ModelCollection<DB> = {
     add<Table extends keyof DB & string>(table: Table, selectable?: Selectable<DB[Table]>): ModelCollection<DB>;
-    get collection(): Data<DB>;
+    addCollection(collection: ModelCollection<DB>): ModelCollection<DB>;
+    get(): Data<DB>;
+    get<Table extends keyof DB & string>(table: Table): Record<number, Selectable<DB[Table]>>;
+    get<Table extends keyof DB & string>(table: Table, id: number): Selectable<DB[Table]> | undefined;
+    getX<Table extends keyof DB & string>(table: Table, id: number): Record<number, Selectable<DB[Table]>>;
 };
 export declare function newModelCollection<DB>(init?: Data<DB>): ModelCollection<DB>;
 type Data<DB> = {

package/dist/types/query-builder.d.ts

@@ -1,6 +1,6 @@
 import { type FetchOneResult, type FetchOneXResult, type FetchSomeResult } from './fetch-result.js';
-import type { AllTableFields, AnyTableField, KyDB, KyselyRizzolverBase, TableName } from './kysely-rizzolver.js';
-import { type Selector, type SelectorResult } from './selector.js';
+import type { KyAllTableFields, KyAnyTableField, KyDB, KyselyRizzolverBase, KyTableName } from './kysely-rizzolver.js';
+import { type Selector, type SelectorResult, AnySelector } from './selector.js';
 import { type ModelCollection } from './model-collection.js';
 import type { UnionToTuple } from './type-helpers.js';
 /**
@@ -12,11 +12,12 @@ import type { UnionToTuple } from './type-helpers.js';
  * method, followed by a call to {@link QueryBuilder.run} to parse the results
  * of the query using a simple builder pattern.
  */
-export interface QueryBuilder<KY extends KyselyRizzolverBase<any, any>, T extends Data<KY>> {
+export interface QueryBuilder<KY extends KyselyRizzolverBase<any, any, any>, T extends Data<KY>> {
     /**
      * The record of {@link Selector} this query builder has, keyed by their alias.
      */
     selectors: T;
+    numSelectors: UnionToTuple<keyof T>['length'];
     /**
      * Given a {@link Selector} alias `k`, Gets a `"table as alias"` expression
      * for that selector.
@@ -37,7 +38,7 @@ export interface QueryBuilder<KY extends KyselyRizzolverBase<any, any>, T extend
      * Gets a const array of all the fields of all the {@link Selector}s this
      * query builder has. The order is arbitrary and should not be relied upon.
      */
-    allFields: FieldsOf<T, keyof T>;
+    allFields(): FieldsOf<T, keyof T>;
     /**
      * Given one of more {@link Selector} aliases, gets an array of
      * `"table.field as alias"` expressions for all of their fields.
@@ -66,11 +67,11 @@ export interface QueryBuilder<KY extends KyselyRizzolverBase<any, any>, T extend
     /**
      * Adds a new {@link Selector} to the query builder.
      */
-    add<Table extends TableName<KY>, Alias extends string, Keys extends readonly AnyTableField<KY, Table>[] = AllTableFields<KY, Table>>(selector: Selector<KY, Table, Alias, Keys>): MoreData<KY, T, Table, Alias, Keys>;
+    add<Table extends KyTableName<KY>, Alias extends string, Keys extends readonly KyAnyTableField<KY, Table>[] = KyAllTableFields<KY, Table>>(selector: Selector<KY, Table, Alias, Keys>): MoreData<KY, T, Table, Alias, Keys>;
     /**
      * Adds a new {@link Selector} to the query builder.
      */
-    add<Table extends TableName<KY>, Alias extends string, Keys extends readonly AnyTableField<KY, Table>[] = AllTableFields<KY, Table>>(table: Table, alias: Alias, keys?: Keys): MoreData<KY, T, Table, Alias, Keys>;
+    add<Table extends KyTableName<KY>, Alias extends string, Keys extends readonly KyAnyTableField<KY, Table>[] = KyAllTableFields<KY, Table>>(table: Table, alias: Alias, keys?: Keys): MoreData<KY, T, Table, Alias, Keys>;
     /**
      * Parses the results of a query into the {@link Selectable} instances
      * defined by the {@link Selector}s this query builder has.
@@ -85,7 +86,7 @@ export interface QueryBuilder<KY extends KyselyRizzolverBase<any, any>, T extend
      *         db
      *             .selectFrom(qb.table('u'))
      *             .leftJoin(qb.table('a'), (join) => join.onRef('u.address_id', '=', 'a.id'))
-     *             .select(qb.allFields)
+     *             .select(qb.allFields())
      *             .execute()
      *     );
      *
@@ -122,19 +123,20 @@ export interface QueryBuilder<KY extends KyselyRizzolverBase<any, any>, T extend
     run<Row extends Record<string, unknown>>(rows: Row[]): DeferredResult<KY, T, Row>;
     run<Row extends Record<string, unknown>>(callback: (qb: this) => Promise<Row[]>): DeferredResult<KY, T, Row>;
 }
-export declare function newQueryBuilder<KY extends KyselyRizzolverBase<any, any>>(rizzolver: KY): QueryBuilder<KY, {}>;
-type Data<KY extends KyselyRizzolverBase<any, any>> = {
+export type AnyQueryBuilder = QueryBuilder<KyselyRizzolverBase<any, any, any>, Record<string, AnySelector<any, string, string, string[]>>>;
+export declare function newQueryBuilder<KY extends KyselyRizzolverBase<any, any, any>>(rizzolver: KY): QueryBuilder<KY, {}>;
+type Data<KY extends KyselyRizzolverBase<any, any, any>> = {
     [alias: string]: Selector<KY, any, string, any>;
 };
-type MoreData<KY extends KyselyRizzolverBase<any, any>, T extends Data<KY>, Table extends TableName<KY>, A extends string, K extends readonly AnyTableField<KY, Table>[] = AllTableFields<KY, Table>> = QueryBuilder<KY, T & {
+type MoreData<KY extends KyselyRizzolverBase<any, any, any>, T extends Data<KY>, Table extends KyTableName<KY>, A extends string, K extends readonly KyAnyTableField<KY, Table>[] = KyAllTableFields<KY, Table>> = QueryBuilder<KY, T & {
     [k in A]: Selector<KY, Table, A, K>;
 }>;
-interface DeferredResult<KY extends KyselyRizzolverBase<any, any>, T extends Data<KY>, Row extends Record<string, unknown>> extends Promise<Result<KY, T, Row>> {
+interface DeferredResult<KY extends KyselyRizzolverBase<any, any, any>, T extends Data<KY>, Row extends Record<string, unknown>> extends Promise<Result<KY, T, Row>> {
     newFetchOneResult<K extends keyof T>(selectorAlias: K): Promise<FetchOneResult<KyDB<KY>, T[K]['input']['table'], SelectorResult<KY, any, T[K]['input']['table'], T[K]['input']['tableFields']>[number]['model'] & {}>>;
     newFetchOneXResult<K extends keyof T>(selectorAlias: K): Promise<FetchOneXResult<KyDB<KY>, T[K]['input']['table'], SelectorResult<KY, any, T[K]['input']['table'], T[K]['input']['tableFields']>[number]['model'] & {}>>;
     newFetchSomeResult<K extends keyof T>(selectorAlias: K): Promise<FetchSomeResult<KyDB<KY>, T[K]['input']['table'], SelectorResult<KY, any, T[K]['input']['table'], T[K]['input']['tableFields']>[number]['model'] & {}>>;
 }
-type Result<KY extends KyselyRizzolverBase<any, any>, T extends Data<KY>, Row extends Record<string, unknown>> = {
+type Result<KY extends KyselyRizzolverBase<any, any, any>, T extends Data<KY>, Row extends Record<string, unknown>> = {
     first: {
         row: Row;
         selectors: {

package/dist/types/selector.d.ts

@@ -1,5 +1,5 @@
 import type { Selectable } from 'kysely';
-import type { AllTableFields, AnyTableField, KyDB, KyselyRizzolverBase, TableName } from './kysely-rizzolver.js';
+import type { AllTableFields, AnyTableField, KyAllTableFields, KyAnyTableField, KyDB, KyselyRizzolverBase, KyTableName, TableName } from './kysely-rizzolver.js';
 /**
  * A {@link Selector} makes it easier to build select expressions for a
  * table in a type-safe way. It can process the results of queries into
@@ -8,7 +8,7 @@ import type { AllTableFields, AnyTableField, KyDB, KyselyRizzolverBase, TableNam
  * {@link Selector} is a low level utility that is used by
  * {@link QueryBuilder} to work with multiple selectors.
  */
-export type Selector<KY extends KyselyRizzolverBase<any, any>, Table extends TableName<KY>, Alias extends string, TableFields extends readonly AnyTableField<KY, Table>[] = AllTableFields<KY, Table>> = {
+export type AnySelector<DB, Table extends TableName<DB>, Alias extends string, TableFields extends AnyTableField<DB, Table>[] = AllTableFields<DB, Table>> = {
     input: {
         /**
          * The table name that's being selected from.
@@ -29,7 +29,66 @@ export type Selector<KY extends KyselyRizzolverBase<any, any>, Table extends Tab
     /**
      * A `"table as alias"` expression for using in select expressions.
      */
-    selectTable: TableAlias<KY, Table, Alias>;
+    selectTable: TableAlias<DB, Table, Alias>;
+    /**
+     * An array of `"table.field as alias"` expressions for using in select expressions.
+     */
+    selectFields: FieldsAsAliases<Alias, TableFields>;
+    /**
+     * A utility method that allows you to reference a specific field.
+     */
+    field<Field extends TableFields[number]>(field: Field): {
+        str: `_${Alias}_${Field}`;
+        /**
+         * A utility method that allows you to reference the field from a different table alias.
+         *
+         * This is useful if you need to reference the field from a subquery for example.
+         */
+        from<A extends string>(alias: A): `${A}.${FieldAlias<Alias, Field>}`;
+    };
+    /**
+     * Parses the results of a query into the model defined by this selector for each row.
+     *
+     * Example:
+     * ```
+     * const selector = newSelector('user', 'u');
+     * const data = await db.selectFrom(selector.tableAlias).selectAll().execute();
+     * const parsed = selector.select(data);
+     *   // => type would be { row: Row, model: Selectable<User> | undefined }[]
+     * ```
+     */
+    select<Row extends Record<string, unknown>>(rows: Row[]): AnySelectorResult<DB, Row, Table, TableFields>;
+};
+/**
+ * A {@link Selector} makes it easier to build select expressions for a
+ * table in a type-safe way. It can process the results of queries into
+ * Kysely's {@link Selectable} instances.
+ *
+ * {@link Selector} is a low level utility that is used by
+ * {@link QueryBuilder} to work with multiple selectors.
+ */
+export type Selector<KY extends KyselyRizzolverBase<any, any, any>, Table extends KyTableName<KY>, Alias extends string, TableFields extends readonly KyAnyTableField<KY, Table>[] = KyAllTableFields<KY, Table>> = {
+    input: {
+        /**
+         * The table name that's being selected from.
+         */
+        table: Table;
+        /**
+         * The alias for the table.
+         */
+        alias: Alias;
+        /**
+         * An array of the fields to be selected from the table.
+         *
+         * This can be omitted, in which case it will default to all the fields of
+         * the table.
+         */
+        tableFields: TableFields;
+    };
+    /**
+     * A `"table as alias"` expression for using in select expressions.
+     */
+    selectTable: KyTableAlias<KY, Table, Alias>;
     /**
      * An array of `"table.field as alias"` expressions for using in select expressions.
      */
@@ -59,13 +118,18 @@ export type Selector<KY extends KyselyRizzolverBase<any, any>, Table extends Tab
      */
     select<Row extends Record<string, unknown>>(rows: Row[]): SelectorResult<KY, Row, Table, TableFields>;
 };
-export declare function newSelector<KY extends KyselyRizzolverBase<any, any>, Table extends TableName<KY>, Alias extends string>(rizzolver: KY, tableName: Table, alias: Alias): Selector<KY, Table, Alias, AllTableFields<KY, Table>>;
-export declare function newSelector<KY extends KyselyRizzolverBase<any, any>, Table extends TableName<KY>, Alias extends string, Keys extends readonly AnyTableField<KY, Table>[]>(rizzolver: KY, tableName: Table, alias: Alias, keys?: Keys): Selector<KY, Table, Alias, Keys>;
-export type SelectorResult<KY extends KyselyRizzolverBase<any, any>, Row extends Record<string, unknown>, Table extends TableName<KY>, TableFields extends readonly AnyTableField<KY, Table>[] = AllTableFields<KY, Table>> = {
+export declare function newSelector<KY extends KyselyRizzolverBase<any, any, any>, Table extends KyTableName<KY>, Alias extends string>(rizzolver: KY, tableName: Table, alias: Alias): Selector<KY, Table, Alias, KyAllTableFields<KY, Table>>;
+export declare function newSelector<KY extends KyselyRizzolverBase<any, any, any>, Table extends KyTableName<KY>, Alias extends string, Keys extends readonly KyAnyTableField<KY, Table>[]>(rizzolver: KY, tableName: Table, alias: Alias, keys?: Keys): Selector<KY, Table, Alias, Keys>;
+export type SelectorResult<KY extends KyselyRizzolverBase<any, any, any>, Row extends Record<string, unknown>, Table extends KyTableName<KY>, TableFields extends readonly KyAnyTableField<KY, Table>[] = KyAllTableFields<KY, Table>> = {
     row: Row;
     model: Selectable<Pick<KyDB<KY>[Table], TableFields[number]>> | undefined;
 }[];
-type TableAlias<KY extends KyselyRizzolverBase<any, any>, Table extends TableName<KY>, Alias extends string> = `${Table} as ${Alias}`;
+export type AnySelectorResult<DB, Row extends Record<string, unknown>, Table extends TableName<DB>, TableFields extends readonly AnyTableField<DB, Table>[] = AllTableFields<DB, Table>> = {
+    row: Row;
+    model: Selectable<Pick<DB[Table], TableFields[number]>> | undefined;
+}[];
+type KyTableAlias<KY extends KyselyRizzolverBase<any, any, any>, Table extends KyTableName<KY>, Alias extends string> = `${Table} as ${Alias}`;
+type TableAlias<DB, Table extends TableName<DB>, Alias extends string> = `${Table} as ${Alias}`;
 type FieldAlias<TableAlias extends string, TableField extends string> = `_${TableAlias}_${TableField}`;
 type FieldAsAlias<TableAlias extends string, TableField extends string> = `${TableAlias}.${TableField} as ${FieldAlias<TableAlias, TableField>}`;
 type FieldsAsAliases<TableAlias extends string, TableFields extends readonly string[]> = TableFields extends readonly [infer TableField extends string, ...infer Tail extends string[]] ? [FieldAsAlias<TableAlias, TableField>, ...FieldsAsAliases<TableAlias, Tail>] : [];

package/dist/types/type-helpers.d.ts

@@ -1,3 +1,4 @@
+import type { Generated } from 'kysely';
 /**
  * I can't explain this.
  *
@@ -8,4 +9,23 @@ type LastInUnion<U> = (U extends any ? () => U : never) extends infer F ? (F ext
  * Recursively converts a union type to a tuple by splitting it into its head and tail.
  */
 export type UnionToTuple<U, Last = LastInUnion<U>> = [U] extends [never] ? [] : [...UnionToTuple<Exclude<U, Last>>, Last];
+/**
+ * Omit properties of `T` that are of type `never`.
+ */
+export type OmitNever<T> = {
+    [K in keyof T as T[K] extends never ? never : K]: T[K];
+};
+/**
+ * Omit properties of `T` that are of type `ValueType`.
+ */
+export type OmitByValue<T, ValueType> = OmitNever<{
+    [K in keyof T]: T[K] extends ValueType ? never : T[K];
+}>;
+export type WithMandatory<T, K extends keyof T> = T & {
+    [P in K]-?: T[P];
+};
+type IsNumericField<T> = T extends Generated<number> ? true : number & T extends never ? never : T extends number ? true : never;
+export type NumericFields<T> = {
+    [K in keyof T]: [IsNumericField<T[K]>] extends [never] ? never : K;
+}[keyof T];
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "kysely-rizzolver",
-	"version": "0.0.2",
+	"version": "0.0.3",
 	"description": "Complex Kysely queries, maximum rizz, type-safe every time.",
 	"author": "YLivay",
 	"repository": {