@decocms/mesh 1.0.0-alpha.1

package/dist/server/node_modules/kysely/dist/esm/query-builder/over-builder.d.ts

@@ -0,0 +1,101 @@
+import type { Expression } from '../expression/expression.js';
+import type { OperationNodeSource } from '../operation-node/operation-node-source.js';
+import { OverNode } from '../operation-node/over-node.js';
+import { type DirectedOrderByStringReference, type OrderByExpression, type OrderByModifiers } from '../parser/order-by-parser.js';
+import { type PartitionByExpression } from '../parser/partition-by-parser.js';
+import type { OrderByInterface } from './order-by-interface.js';
+export declare class OverBuilder<DB, TB extends keyof DB> implements OrderByInterface<DB, TB, {}>, OperationNodeSource {
+    #private;
+    constructor(props: OverBuilderProps);
+    /**
+     * Adds an `order by` clause or item inside the `over` function.
+     *
+     * ```ts
+     * const result = await db
+     *   .selectFrom('person')
+     *   .select(
+     *     (eb) => eb.fn.avg<number>('age').over(
+     *       ob => ob.orderBy('first_name', 'asc').orderBy('last_name', 'asc')
+     *     ).as('average_age')
+     *   )
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select avg("age") over(order by "first_name" asc, "last_name" asc) as "average_age"
+     * from "person"
+     * ```
+     */
+    orderBy<OE extends OrderByExpression<DB, TB, {}>>(expr: OE, modifiers?: OrderByModifiers): OverBuilder<DB, TB>;
+    /**
+     * @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, {}> | DirectedOrderByStringReference<DB, TB, {}>>(exprs: ReadonlyArray<OE>): OverBuilder<DB, TB>;
+    /**
+     * @deprecated It does ~2.9x more compile-time instantiations compared to a `orderBy(expr, direction)` call.
+     */
+    orderBy<OE extends DirectedOrderByStringReference<DB, TB, {}>>(expr: OE): OverBuilder<DB, TB>;
+    /**
+     * @deprecated Use `orderBy(expr, (ob) => ...)` instead.
+     */
+    orderBy<OE extends OrderByExpression<DB, TB, {}>>(expr: OE, modifiers: Expression<any>): OverBuilder<DB, TB>;
+    /**
+     * 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(): OverBuilder<DB, TB>;
+    /**
+     * Adds partition by clause item/s inside the over function.
+     *
+     * ```ts
+     * const result = await db
+     *   .selectFrom('person')
+     *   .select(
+     *     (eb) => eb.fn.avg<number>('age').over(
+     *       ob => ob.partitionBy(['last_name', 'first_name'])
+     *     ).as('average_age')
+     *   )
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select avg("age") over(partition by "last_name", "first_name") as "average_age"
+     * from "person"
+     * ```
+     */
+    partitionBy(partitionBy: ReadonlyArray<PartitionByExpression<DB, TB>>): OverBuilder<DB, TB>;
+    partitionBy<PE extends PartitionByExpression<DB, TB>>(partitionBy: PE): OverBuilder<DB, TB>;
+    /**
+     * Simply calls the provided function passing `this` as the only argument. `$call` returns
+     * what the provided function returns.
+     */
+    $call<T>(func: (qb: this) => T): T;
+    toOperationNode(): OverNode;
+}
+export interface OverBuilderProps {
+    readonly overNode: OverNode;
+}

package/dist/server/node_modules/kysely/dist/esm/query-builder/over-builder.js

@@ -0,0 +1,37 @@
+/// <reference types="./over-builder.d.ts" />
+import { OverNode } from '../operation-node/over-node.js';
+import { QueryNode } from '../operation-node/query-node.js';
+import { parseOrderBy, } from '../parser/order-by-parser.js';
+import { parsePartitionBy, } from '../parser/partition-by-parser.js';
+import { freeze } from '../util/object-utils.js';
+export class OverBuilder {
+    #props;
+    constructor(props) {
+        this.#props = freeze(props);
+    }
+    orderBy(...args) {
+        return new OverBuilder({
+            overNode: OverNode.cloneWithOrderByItems(this.#props.overNode, parseOrderBy(args)),
+        });
+    }
+    clearOrderBy() {
+        return new OverBuilder({
+            overNode: QueryNode.cloneWithoutOrderBy(this.#props.overNode),
+        });
+    }
+    partitionBy(partitionBy) {
+        return new OverBuilder({
+            overNode: OverNode.cloneWithPartitionByItems(this.#props.overNode, parsePartitionBy(partitionBy)),
+        });
+    }
+    /**
+     * Simply calls the provided function passing `this` as the only argument. `$call` returns
+     * what the provided function returns.
+     */
+    $call(func) {
+        return func(this);
+    }
+    toOperationNode() {
+        return this.#props.overNode;
+    }
+}

package/dist/server/node_modules/kysely/dist/esm/query-builder/returning-interface.d.ts

@@ -0,0 +1,91 @@
+import type { ReturningAllRow, ReturningCallbackRow, ReturningRow } from '../parser/returning-parser.js';
+import type { SelectCallback, SelectExpression } from '../parser/select-parser.js';
+import type { Selectable } from '../util/column-type.js';
+export interface ReturningInterface<DB, TB extends keyof DB, O> {
+    /**
+     * Allows you to return data from modified rows.
+     *
+     * On supported databases like PostgreSQL, this method can be chained to
+     * `insert`, `update`, `delete` and `merge` queries to return data.
+     *
+     * Note that on SQLite you need to give aliases for the expressions to avoid
+     * [this bug](https://sqlite.org/forum/forumpost/033daf0b32) in SQLite.
+     * For example `.returning('id as id')`.
+     *
+     * Also see the {@link returningAll} method.
+     *
+     * ### Examples
+     *
+     * Return one column:
+     *
+     * ```ts
+     * const { id } = await db
+     *   .insertInto('person')
+     *   .values({
+     *     first_name: 'Jennifer',
+     *     last_name: 'Aniston'
+     *   })
+     *   .returning('id')
+     *   .executeTakeFirstOrThrow()
+     * ```
+     *
+     * Return multiple columns:
+     *
+     * ```ts
+     * const { id, last_name } = await db
+     *   .insertInto('person')
+     *   .values({
+     *     first_name: 'Jennifer',
+     *     last_name: 'Aniston'
+     *   })
+     *   .returning(['id', 'last_name'])
+     *   .executeTakeFirstOrThrow()
+     * ```
+     *
+     * Return arbitrary expressions:
+     *
+     * ```ts
+     * import { sql } from 'kysely'
+     *
+     * const { id, full_name, first_pet_id } = await db
+     *   .insertInto('person')
+     *   .values({
+     *     first_name: 'Jennifer',
+     *     last_name: 'Aniston'
+     *   })
+     *   .returning((eb) => [
+     *     'id as id',
+     *     sql<string>`concat(first_name, ' ', last_name)`.as('full_name'),
+     *     eb.selectFrom('pet').select('pet.id').limit(1).as('first_pet_id')
+     *   ])
+     *   .executeTakeFirstOrThrow()
+     * ```
+     */
+    returning<SE extends SelectExpression<DB, TB>>(selections: ReadonlyArray<SE>): ReturningInterface<DB, TB, ReturningRow<DB, TB, O, SE>>;
+    returning<CB extends SelectCallback<DB, TB>>(callback: CB): ReturningInterface<DB, TB, ReturningCallbackRow<DB, TB, O, CB>>;
+    returning<SE extends SelectExpression<DB, TB>>(selection: SE): ReturningInterface<DB, TB, ReturningRow<DB, TB, O, SE>>;
+    /**
+     * Adds a `returning *` to an insert/update/delete/merge query on databases
+     * that support `returning` such as PostgreSQL.
+     *
+     * Also see the {@link returning} method.
+     */
+    returningAll(): ReturningInterface<DB, TB, Selectable<DB[TB]>>;
+}
+export interface MultiTableReturningInterface<DB, TB extends keyof DB, O> extends ReturningInterface<DB, TB, O> {
+    /**
+     * Adds a `returning *` or `returning table.*` to an insert/update/delete/merge
+     * query on databases that support `returning` such as PostgreSQL.
+     *
+     * Also see the {@link returning} method.
+     */
+    returningAll<T extends TB>(tables: ReadonlyArray<T>): MultiTableReturningInterface<DB, TB, ReturningAllRow<DB, T, O>>;
+    /**
+     * Adds a `returning *` to an insert/update/delete/merge query on databases
+     * that support `returning` such as PostgreSQL.
+     *
+     * Also see the {@link returning} method.
+     */
+    returningAll<T extends TB>(table: T): MultiTableReturningInterface<DB, TB, ReturningAllRow<DB, T, O>>;
+    returningAll(): ReturningInterface<DB, TB, Selectable<DB[TB]>>;
+}

package/dist/server/node_modules/kysely/dist/esm/query-builder/returning-interface.js

@@ -0,0 +1,2 @@
+/// <reference types="./returning-interface.d.ts" />
+export {};

package/dist/server/node_modules/kysely/dist/esm/query-builder/select-query-builder-expression.d.ts

@@ -0,0 +1,28 @@
+import type { AliasableExpression } from '../expression/expression.js';
+import type { SelectQueryNode } from '../operation-node/select-query-node.js';
+export interface SelectQueryBuilderExpression<O> extends AliasableExpression<O> {
+    get isSelectQueryBuilder(): true;
+    /**
+     * Creates the OperationNode that describes how to compile this expression into SQL.
+     *
+     * ### Examples
+     *
+     * If you are creating a custom expression, it's often easiest to use the {@link sql}
+     * template tag to build the node:
+     *
+     * ```ts
+     * import { type Expression, type OperationNode, sql } from 'kysely'
+     *
+     * class SomeExpression<T> implements Expression<T> {
+     *   get expressionType(): T | undefined {
+     *     return undefined
+     *   }
+     *
+     *   toOperationNode(): OperationNode {
+     *     return sql`some sql here`.toOperationNode()
+     *   }
+     * }
+     * ```
+     */
+    toOperationNode(): SelectQueryNode;
+}

package/dist/server/node_modules/kysely/dist/esm/query-builder/select-query-builder-expression.js

@@ -0,0 +1,2 @@
+/// <reference types="./select-query-builder-expression.d.ts" />
+export {};