FM / query-builder

/opt/canhelp/node_modules/kysely/dist/esm/query-builder/

/opt/canhelp/node_modules/kysely/dist/esm/query-builder

Name	Size	Mode	Actions
aggregate-function-builder.d.ts	13602	0644	edit dl rm
aggregate-function-builder.js	7666	0644	edit dl rm
case-builder.d.ts	6689	0644	edit dl rm
case-builder.js	2563	0644	edit dl rm
cte-builder.d.ts	802	0644	edit dl rm
cte-builder.js	961	0644	edit dl rm
delete-query-builder.d.ts	47443	0644	edit dl rm
delete-query-builder.js	15843	0644	edit dl rm
delete-result.d.ts	116	0644	edit dl rm
delete-result.js	183	0644	edit dl rm
function-module.d.ts	23521	0644	edit dl rm
function-module.js	2299	0644	edit dl rm
having-interface.d.ts	953	0644	edit dl rm
having-interface.js	61	0644	edit dl rm
insert-query-builder.d.ts	40215	0644	edit dl rm
insert-query-builder.js	35726	0644	edit dl rm
insert-result.d.ts	1735	0644	edit dl rm
insert-result.js	1783	0644	edit dl rm
join-builder.d.ts	1773	0644	edit dl rm
join-builder.js	1583	0644	edit dl rm
json-path-builder.d.ts	9545	0644	edit dl rm
json-path-builder.js	5817	0644	edit dl rm
merge-query-builder.d.ts	37025	0644	edit dl rm
merge-query-builder.js	20065	0644	edit dl rm
merge-result.d.ts	139	0644	edit dl rm
merge-result.js	181	0644	edit dl rm
no-result-error.d.ts	478	0644	edit dl rm
no-result-error.js	384	0644	edit dl rm
on-conflict-builder.d.ts	25573	0644	edit dl rm
on-conflict-builder.js	8116	0644	edit dl rm
order-by-interface.d.ts	4883	0644	edit dl rm
order-by-interface.js	63	0644	edit dl rm
order-by-item-builder.d.ts	1372	0644	edit dl rm
order-by-item-builder.js	2132	0644	edit dl rm
output-interface.d.ts	5477	0644	edit dl rm
output-interface.js	61	0644	edit dl rm
over-builder.d.ts	3755	0644	edit dl rm
over-builder.js	1239	0644	edit dl rm
returning-interface.d.ts	3496	0644	edit dl rm
returning-interface.js	64	0644	edit dl rm
select-query-builder-expression.d.ts	962	0644	edit dl rm
select-query-builder-expression.js	76	0644	edit dl rm
select-query-builder.d.ts	78467	0644	edit dl rm
select-query-builder.js	13062	0644	edit dl rm
update-query-builder.d.ts	50254	0644	edit dl rm
update-query-builder.js	16441	0644	edit dl rm
update-result.d.ts	497	0644	edit dl rm
update-result.js	572	0644	edit dl rm
where-interface.d.ts	10814	0644	edit dl rm
where-interface.js	60	0644	edit dl rm

Edit: /opt/canhelp/node_modules/kysely/dist/esm/query-builder/order-by-interface.d.ts (4883B)

import type { Expression } from '../expression/expression.js';
import type { OrderByExpression, DirectedOrderByStringReference, OrderByModifiers } from '../parser/order-by-parser.js';
export interface OrderByInterface<DB, TB extends keyof DB, O> {
    /**
     * Adds an `order by` clause to the query.
     *
     * `orderBy` calls are additive. Meaning, additional `orderBy` calls append to
     * the existing order by clause.
     *
     * `orderBy` is supported in select queries on all dialects. In MySQL, you can
     * also use `orderBy` in update and delete queries.
     *
     * In a single call you can add a single column/expression or multiple columns/expressions.
     *
     * Single column/expression calls can have 1-2 arguments. The first argument is
     * the expression to order by, while the second optional argument is the direction
     * (`asc` or `desc`), a callback that accepts and returns an {@link OrderByItemBuilder}
     * or an expression.
     *
     * See {@link clearOrderBy} to remove the `order by` clause from a query.
     *
     * ### Examples
     *
     * Single column/expression per call:
     *
     * ```ts
     * await db
     *   .selectFrom('person')
     *   .select('person.first_name as fn')
     *   .orderBy('id')
     *   .orderBy('fn', 'desc')
     *   .execute()
     * ```
     *
     * The generated SQL (PostgreSQL):
     *
     * ```sql
     * select "person"."first_name" as "fn"
     * from "person"
     * order by "id", "fn" desc
     * ```
     *
     * Building advanced modifiers:
     *
     * ```ts
     * await db
     *   .selectFrom('person')
     *   .select('person.first_name as fn')
     *   .orderBy('id', (ob) => ob.desc().nullsFirst())
     *   .execute()
     * ```
     *
     * The generated SQL (PostgreSQL):
     *
     * ```sql
     * select "person"."first_name" as "fn"
     * from "person"
     * order by "id" desc nulls first
     * ```
     *
     * The order by expression can also be a raw sql expression or a subquery
     * in addition to column references:
     *
     * ```ts
     * import { sql } from 'kysely'
     *
     * await db
     *   .selectFrom('person')
     *   .selectAll()
     *   .orderBy((eb) => eb.selectFrom('pet')
     *     .select('pet.name')
     *     .whereRef('pet.owner_id', '=', 'person.id')
     *     .limit(1)
     *   )
     *   .orderBy(
     *     sql<string>`concat(first_name, last_name) asc`
     *   )
     *   .execute()
     * ```
     *
     * The generated SQL (PostgreSQL):
     *
     * ```sql
     * select *
     * from "person"
     * order by
     *   ( select "pet"."name"
     *     from "pet"
     *     where "pet"."owner_id" = "person"."id"
     *     limit $1
     *   ) asc,
     *   concat(first_name, last_name) asc
     * ```
     *
     * `dynamic.ref` can be used to refer to columns not known at
     * compile time:
     *
     * ```ts
     * async function someQuery(orderBy: string) {
     *   const { ref } = db.dynamic
     *
     *   return await db
     *     .selectFrom('person')
     *     .select('person.first_name as fn')
     *     .orderBy(ref(orderBy))
     *     .execute()
     * }
     *
     * someQuery('fn')
     * ```
     *
     * The generated SQL (PostgreSQL):
     *
     * ```sql
     * select "person"."first_name" as "fn"
     * from "person"
     * order by "fn"
     * ```
     */
    orderBy<OE extends OrderByExpression<DB, TB, O>>(expr: OE, modifiers?: OrderByModifiers): OrderByInterface<DB, TB, O>;
    /**
     * @deprecated It does ~2-2.6x more compile-time instantiations compared to multiple chained `orderBy(expr, modifiers?)` calls (in `order by` clauses with reasonable item counts), and has broken autocompletion.
     */
    orderBy<OE extends OrderByExpression<DB, TB, O> | DirectedOrderByStringReference<DB, TB, O>>(exprs: ReadonlyArray<OE>): OrderByInterface<DB, TB, O>;
    /**
     * @deprecated It does ~2.9x more compile-time instantiations compared to a `orderBy(expr, direction)` call.
     */
    orderBy<OE extends DirectedOrderByStringReference<DB, TB, O>>(expr: OE): OrderByInterface<DB, TB, O>;
    /**
     * @deprecated Use `orderBy(expr, (ob) => ...)` instead.
     */
    orderBy<OE extends OrderByExpression<DB, TB, O>>(expr: OE, modifiers: Expression<any>): OrderByInterface<DB, TB, O>;
    /**
     * Clears the `order by` clause from the query.
     *
     * See {@link orderBy} for adding an `order by` clause or item to a query.
     *
     * ### Examples
     *
     * ```ts
     * const query = db
     *   .selectFrom('person')
     *   .selectAll()
     *   .orderBy('id', 'desc')
     *
     * const results = await query
     *   .clearOrderBy()
     *   .execute()
     * ```
     *
     * The generated SQL (PostgreSQL):
     *
     * ```sql
     * select * from "person"
     * ```
     */
    clearOrderBy(): OrderByInterface<DB, TB, O>;
}

cmd: