@decocms/mesh 1.0.0-alpha.1

package/dist/server/node_modules/kysely/dist/cjs/query-builder/aggregate-function-builder.js

@@ -0,0 +1,242 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AliasedAggregateFunctionBuilder = exports.AggregateFunctionBuilder = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+const aggregate_function_node_js_1 = require("../operation-node/aggregate-function-node.js");
+const alias_node_js_1 = require("../operation-node/alias-node.js");
+const identifier_node_js_1 = require("../operation-node/identifier-node.js");
+const parse_utils_js_1 = require("../parser/parse-utils.js");
+const binary_operation_parser_js_1 = require("../parser/binary-operation-parser.js");
+const order_by_parser_js_1 = require("../parser/order-by-parser.js");
+const query_node_js_1 = require("../operation-node/query-node.js");
+class AggregateFunctionBuilder {
+    #props;
+    constructor(props) {
+        this.#props = (0, object_utils_js_1.freeze)(props);
+    }
+    /** @private */
+    get expressionType() {
+        return undefined;
+    }
+    /**
+     * Returns an aliased version of the function.
+     *
+     * In addition to slapping `as "the_alias"` to the end of the SQL,
+     * this method also provides strict typing:
+     *
+     * ```ts
+     * const result = await db
+     *   .selectFrom('person')
+     *   .select(
+     *     (eb) => eb.fn.count<number>('id').as('person_count')
+     *   )
+     *   .executeTakeFirstOrThrow()
+     *
+     * // `person_count: number` field exists in the result type.
+     * console.log(result.person_count)
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select count("id") as "person_count"
+     * from "person"
+     * ```
+     */
+    as(alias) {
+        return new AliasedAggregateFunctionBuilder(this, alias);
+    }
+    /**
+     * Adds a `distinct` clause inside the function.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * const result = await db
+     *   .selectFrom('person')
+     *   .select((eb) =>
+     *     eb.fn.count<number>('first_name').distinct().as('first_name_count')
+     *   )
+     *   .executeTakeFirstOrThrow()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select count(distinct "first_name") as "first_name_count"
+     * from "person"
+     * ```
+     */
+    distinct() {
+        return new AggregateFunctionBuilder({
+            ...this.#props,
+            aggregateFunctionNode: aggregate_function_node_js_1.AggregateFunctionNode.cloneWithDistinct(this.#props.aggregateFunctionNode),
+        });
+    }
+    orderBy(...args) {
+        return new AggregateFunctionBuilder({
+            ...this.#props,
+            aggregateFunctionNode: query_node_js_1.QueryNode.cloneWithOrderByItems(this.#props.aggregateFunctionNode, (0, order_by_parser_js_1.parseOrderBy)(args)),
+        });
+    }
+    clearOrderBy() {
+        return new AggregateFunctionBuilder({
+            ...this.#props,
+            aggregateFunctionNode: query_node_js_1.QueryNode.cloneWithoutOrderBy(this.#props.aggregateFunctionNode),
+        });
+    }
+    withinGroupOrderBy(...args) {
+        return new AggregateFunctionBuilder({
+            ...this.#props,
+            aggregateFunctionNode: aggregate_function_node_js_1.AggregateFunctionNode.cloneWithOrderBy(this.#props.aggregateFunctionNode, (0, order_by_parser_js_1.parseOrderBy)(args), true),
+        });
+    }
+    filterWhere(...args) {
+        return new AggregateFunctionBuilder({
+            ...this.#props,
+            aggregateFunctionNode: aggregate_function_node_js_1.AggregateFunctionNode.cloneWithFilter(this.#props.aggregateFunctionNode, (0, binary_operation_parser_js_1.parseValueBinaryOperationOrExpression)(args)),
+        });
+    }
+    /**
+     * Adds a `filter` clause with a nested `where` clause after the function, where
+     * both sides of the operator are references to columns.
+     *
+     * Similar to {@link WhereInterface}'s `whereRef` method.
+     *
+     * ### Examples
+     *
+     * Count people with same first and last names versus general public:
+     *
+     * ```ts
+     * const result = await db
+     *   .selectFrom('person')
+     *   .select((eb) => [
+     *     eb.fn
+     *       .count<number>('id')
+     *       .filterWhereRef('first_name', '=', 'last_name')
+     *       .as('repeat_name_count'),
+     *     eb.fn.count<number>('id').as('total_count'),
+     *   ])
+     *   .executeTakeFirstOrThrow()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select
+     *   count("id") filter(where "first_name" = "last_name") as "repeat_name_count",
+     *   count("id") as "total_count"
+     * from "person"
+     * ```
+     */
+    filterWhereRef(lhs, op, rhs) {
+        return new AggregateFunctionBuilder({
+            ...this.#props,
+            aggregateFunctionNode: aggregate_function_node_js_1.AggregateFunctionNode.cloneWithFilter(this.#props.aggregateFunctionNode, (0, binary_operation_parser_js_1.parseReferentialBinaryOperation)(lhs, op, rhs)),
+        });
+    }
+    /**
+     * Adds an `over` clause (window functions) after the function.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * const result = await db
+     *   .selectFrom('person')
+     *   .select(
+     *     (eb) => eb.fn.avg<number>('age').over().as('average_age')
+     *   )
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select avg("age") over() as "average_age"
+     * from "person"
+     * ```
+     *
+     * Also supports passing a callback that returns an over builder,
+     * allowing to add partition by and sort by clauses inside over.
+     *
+     * ```ts
+     * const result = await db
+     *   .selectFrom('person')
+     *   .select(
+     *     (eb) => eb.fn.avg<number>('age').over(
+     *       ob => ob.partitionBy('last_name').orderBy('first_name', 'asc')
+     *     ).as('average_age')
+     *   )
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select avg("age") over(partition by "last_name" order by "first_name" asc) as "average_age"
+     * from "person"
+     * ```
+     */
+    over(over) {
+        const builder = (0, parse_utils_js_1.createOverBuilder)();
+        return new AggregateFunctionBuilder({
+            ...this.#props,
+            aggregateFunctionNode: aggregate_function_node_js_1.AggregateFunctionNode.cloneWithOver(this.#props.aggregateFunctionNode, (over ? over(builder) : builder).toOperationNode()),
+        });
+    }
+    /**
+     * Simply calls the provided function passing `this` as the only argument. `$call` returns
+     * what the provided function returns.
+     */
+    $call(func) {
+        return func(this);
+    }
+    /**
+     * Casts the expression to the given type.
+     *
+     * This method call doesn't change the SQL in any way. This methods simply
+     * returns a copy of this `AggregateFunctionBuilder` with a new output type.
+     */
+    $castTo() {
+        return new AggregateFunctionBuilder(this.#props);
+    }
+    /**
+     * Omit null from the expression's type.
+     *
+     * This function can be useful in cases where you know an expression can't be
+     * null, but Kysely is unable to infer it.
+     *
+     * This method call doesn't change the SQL in any way. This methods simply
+     * returns a copy of `this` with a new output type.
+     */
+    $notNull() {
+        return new AggregateFunctionBuilder(this.#props);
+    }
+    toOperationNode() {
+        return this.#props.aggregateFunctionNode;
+    }
+}
+exports.AggregateFunctionBuilder = AggregateFunctionBuilder;
+/**
+ * {@link AggregateFunctionBuilder} with an alias. The result of calling {@link AggregateFunctionBuilder.as}.
+ */
+class AliasedAggregateFunctionBuilder {
+    #aggregateFunctionBuilder;
+    #alias;
+    constructor(aggregateFunctionBuilder, alias) {
+        this.#aggregateFunctionBuilder = aggregateFunctionBuilder;
+        this.#alias = alias;
+    }
+    /** @private */
+    get expression() {
+        return this.#aggregateFunctionBuilder;
+    }
+    /** @private */
+    get alias() {
+        return this.#alias;
+    }
+    toOperationNode() {
+        return alias_node_js_1.AliasNode.create(this.#aggregateFunctionBuilder.toOperationNode(), identifier_node_js_1.IdentifierNode.create(this.#alias));
+    }
+}
+exports.AliasedAggregateFunctionBuilder = AliasedAggregateFunctionBuilder;

package/dist/server/node_modules/kysely/dist/cjs/query-builder/case-builder.d.ts

@@ -0,0 +1,112 @@
+import type { Expression } from '../expression/expression.js';
+import { ExpressionWrapper } from '../expression/expression-wrapper.js';
+import type { ReferenceExpression } from '../parser/reference-parser.js';
+import { CaseNode } from '../operation-node/case-node.js';
+import { type ComparisonOperatorExpression, type OperandValueExpressionOrList } from '../parser/binary-operation-parser.js';
+import { type ExtractTypeFromValueExpression } from '../parser/value-parser.js';
+import type { KyselyTypeError } from '../util/type-error.js';
+export declare class CaseBuilder<DB, TB extends keyof DB, W = unknown, O = never> implements Whenable<DB, TB, W, O> {
+    #private;
+    constructor(props: CaseBuilderProps);
+    /**
+     * Adds a `when` clause to the case statement.
+     *
+     * A `when` call must be followed by a {@link CaseThenBuilder.then} call.
+     */
+    when<RE extends ReferenceExpression<DB, TB>, VE extends OperandValueExpressionOrList<DB, TB, RE>>(lhs: unknown extends W ? RE : KyselyTypeError<'when(lhs, op, rhs) is not supported when using case(value)'>, op: ComparisonOperatorExpression, rhs: VE): CaseThenBuilder<DB, TB, W, O>;
+    when(expression: Expression<W>): CaseThenBuilder<DB, TB, W, O>;
+    when(value: unknown extends W ? KyselyTypeError<'when(value) is only supported when using case(value)'> : W): CaseThenBuilder<DB, TB, W, O>;
+}
+interface CaseBuilderProps {
+    readonly node: CaseNode;
+}
+export declare class CaseThenBuilder<DB, TB extends keyof DB, W, O> {
+    #private;
+    constructor(props: CaseBuilderProps);
+    /**
+     * Adds a `then` clause to the `case` statement.
+     *
+     * A `then` call can be followed by {@link Whenable.when}, {@link CaseWhenBuilder.else},
+     * {@link CaseWhenBuilder.end} or {@link CaseWhenBuilder.endCase} call.
+     */
+    then<E extends Expression<unknown>>(expression: E): CaseWhenBuilder<DB, TB, W, O | ExtractTypeFromValueExpression<E>>;
+    then<V>(value: V): CaseWhenBuilder<DB, TB, W, O | V>;
+}
+export declare class CaseWhenBuilder<DB, TB extends keyof DB, W, O> implements Whenable<DB, TB, W, O>, Endable<DB, TB, O | null> {
+    #private;
+    constructor(props: CaseBuilderProps);
+    /**
+     * Adds a `when` clause to the case statement.
+     *
+     * A `when` call must be followed by a {@link CaseThenBuilder.then} call.
+     */
+    when<RE extends ReferenceExpression<DB, TB>, VE extends OperandValueExpressionOrList<DB, TB, RE>>(lhs: unknown extends W ? RE : KyselyTypeError<'when(lhs, op, rhs) is not supported when using case(value)'>, op: ComparisonOperatorExpression, rhs: VE): CaseThenBuilder<DB, TB, W, O>;
+    when(expression: Expression<W>): CaseThenBuilder<DB, TB, W, O>;
+    when(value: unknown extends W ? KyselyTypeError<'when(value) is only supported when using case(value)'> : W): CaseThenBuilder<DB, TB, W, O>;
+    /**
+     * Adds an `else` clause to the `case` statement.
+     *
+     * An `else` call must be followed by an {@link Endable.end} or {@link Endable.endCase} call.
+     */
+    else<E extends Expression<unknown>>(expression: E): CaseEndBuilder<DB, TB, O | ExtractTypeFromValueExpression<E>>;
+    else<V>(value: V): CaseEndBuilder<DB, TB, O | V>;
+    /**
+     * Adds an `end` keyword to the case operator.
+     *
+     * `case` operators can only be used as part of a query.
+     * For a `case` statement used as part of a stored program, use {@link endCase} instead.
+     */
+    end(): ExpressionWrapper<DB, TB, O | null>;
+    /**
+     * Adds `end case` keywords to the case statement.
+     *
+     * `case` statements can only be used for flow control in stored programs.
+     * For a `case` operator used as part of a query, use {@link end} instead.
+     */
+    endCase(): ExpressionWrapper<DB, TB, O | null>;
+}
+export declare class CaseEndBuilder<DB, TB extends keyof DB, O> implements Endable<DB, TB, O> {
+    #private;
+    constructor(props: CaseBuilderProps);
+    /**
+     * Adds an `end` keyword to the case operator.
+     *
+     * `case` operators can only be used as part of a query.
+     * For a `case` statement used as part of a stored program, use {@link endCase} instead.
+     */
+    end(): ExpressionWrapper<DB, TB, O>;
+    /**
+     * Adds `end case` keywords to the case statement.
+     *
+     * `case` statements can only be used for flow control in stored programs.
+     * For a `case` operator used as part of a query, use {@link end} instead.
+     */
+    endCase(): ExpressionWrapper<DB, TB, O>;
+}
+interface Whenable<DB, TB extends keyof DB, W, O> {
+    /**
+     * Adds a `when` clause to the case statement.
+     *
+     * A `when` call must be followed by a {@link CaseThenBuilder.then} call.
+     */
+    when<RE extends ReferenceExpression<DB, TB>, VE extends OperandValueExpressionOrList<DB, TB, RE>>(lhs: unknown extends W ? RE : KyselyTypeError<'when(lhs, op, rhs) is not supported when using case(value)'>, op: ComparisonOperatorExpression, rhs: VE): CaseThenBuilder<DB, TB, W, O>;
+    when(expression: Expression<W>): CaseThenBuilder<DB, TB, W, O>;
+    when(value: unknown extends W ? KyselyTypeError<'when(value) is only supported when using case(value)'> : W): CaseThenBuilder<DB, TB, W, O>;
+}
+interface Endable<DB, TB extends keyof DB, O> {
+    /**
+     * Adds an `end` keyword to the case operator.
+     *
+     * `case` operators can only be used as part of a query.
+     * For a `case` statement used as part of a stored program, use {@link endCase} instead.
+     */
+    end(): ExpressionWrapper<DB, TB, O>;
+    /**
+     * Adds `end case` keywords to the case statement.
+     *
+     * `case` statements can only be used for flow control in stored programs.
+     * For a `case` operator used as part of a query, use {@link end} instead.
+     */
+    endCase(): ExpressionWrapper<DB, TB, O>;
+}
+export {};

package/dist/server/node_modules/kysely/dist/cjs/query-builder/case-builder.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CaseEndBuilder = exports.CaseWhenBuilder = exports.CaseThenBuilder = exports.CaseBuilder = void 0;
+const expression_wrapper_js_1 = require("../expression/expression-wrapper.js");
+const object_utils_js_1 = require("../util/object-utils.js");
+const case_node_js_1 = require("../operation-node/case-node.js");
+const when_node_js_1 = require("../operation-node/when-node.js");
+const binary_operation_parser_js_1 = require("../parser/binary-operation-parser.js");
+const value_parser_js_1 = require("../parser/value-parser.js");
+class CaseBuilder {
+    #props;
+    constructor(props) {
+        this.#props = (0, object_utils_js_1.freeze)(props);
+    }
+    when(...args) {
+        return new CaseThenBuilder({
+            ...this.#props,
+            node: case_node_js_1.CaseNode.cloneWithWhen(this.#props.node, when_node_js_1.WhenNode.create((0, binary_operation_parser_js_1.parseValueBinaryOperationOrExpression)(args))),
+        });
+    }
+}
+exports.CaseBuilder = CaseBuilder;
+class CaseThenBuilder {
+    #props;
+    constructor(props) {
+        this.#props = (0, object_utils_js_1.freeze)(props);
+    }
+    then(valueExpression) {
+        return new CaseWhenBuilder({
+            ...this.#props,
+            node: case_node_js_1.CaseNode.cloneWithThen(this.#props.node, (0, value_parser_js_1.isSafeImmediateValue)(valueExpression)
+                ? (0, value_parser_js_1.parseSafeImmediateValue)(valueExpression)
+                : (0, value_parser_js_1.parseValueExpression)(valueExpression)),
+        });
+    }
+}
+exports.CaseThenBuilder = CaseThenBuilder;
+class CaseWhenBuilder {
+    #props;
+    constructor(props) {
+        this.#props = (0, object_utils_js_1.freeze)(props);
+    }
+    when(...args) {
+        return new CaseThenBuilder({
+            ...this.#props,
+            node: case_node_js_1.CaseNode.cloneWithWhen(this.#props.node, when_node_js_1.WhenNode.create((0, binary_operation_parser_js_1.parseValueBinaryOperationOrExpression)(args))),
+        });
+    }
+    else(valueExpression) {
+        return new CaseEndBuilder({
+            ...this.#props,
+            node: case_node_js_1.CaseNode.cloneWith(this.#props.node, {
+                else: (0, value_parser_js_1.isSafeImmediateValue)(valueExpression)
+                    ? (0, value_parser_js_1.parseSafeImmediateValue)(valueExpression)
+                    : (0, value_parser_js_1.parseValueExpression)(valueExpression),
+            }),
+        });
+    }
+    end() {
+        return new expression_wrapper_js_1.ExpressionWrapper(case_node_js_1.CaseNode.cloneWith(this.#props.node, { isStatement: false }));
+    }
+    endCase() {
+        return new expression_wrapper_js_1.ExpressionWrapper(case_node_js_1.CaseNode.cloneWith(this.#props.node, { isStatement: true }));
+    }
+}
+exports.CaseWhenBuilder = CaseWhenBuilder;
+class CaseEndBuilder {
+    #props;
+    constructor(props) {
+        this.#props = (0, object_utils_js_1.freeze)(props);
+    }
+    end() {
+        return new expression_wrapper_js_1.ExpressionWrapper(case_node_js_1.CaseNode.cloneWith(this.#props.node, { isStatement: false }));
+    }
+    endCase() {
+        return new expression_wrapper_js_1.ExpressionWrapper(case_node_js_1.CaseNode.cloneWith(this.#props.node, { isStatement: true }));
+    }
+}
+exports.CaseEndBuilder = CaseEndBuilder;

package/dist/server/node_modules/kysely/dist/cjs/query-builder/cte-builder.d.ts

@@ -0,0 +1,20 @@
+import type { OperationNodeSource } from '../operation-node/operation-node-source.js';
+import { CommonTableExpressionNode } from '../operation-node/common-table-expression-node.js';
+export declare class CTEBuilder<N extends string> implements OperationNodeSource {
+    #private;
+    constructor(props: CTEBuilderProps);
+    /**
+     * Makes the common table expression materialized.
+     */
+    materialized(): CTEBuilder<N>;
+    /**
+     * Makes the common table expression not materialized.
+     */
+    notMaterialized(): CTEBuilder<N>;
+    toOperationNode(): CommonTableExpressionNode;
+}
+interface CTEBuilderProps {
+    readonly node: CommonTableExpressionNode;
+}
+export type CTEBuilderCallback<N extends string> = (cte: <N2 extends string>(name: N2) => CTEBuilder<N2>) => CTEBuilder<N>;
+export {};

package/dist/server/node_modules/kysely/dist/cjs/query-builder/cte-builder.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CTEBuilder = void 0;
+const common_table_expression_node_js_1 = require("../operation-node/common-table-expression-node.js");
+const object_utils_js_1 = require("../util/object-utils.js");
+class CTEBuilder {
+    #props;
+    constructor(props) {
+        this.#props = (0, object_utils_js_1.freeze)(props);
+    }
+    /**
+     * Makes the common table expression materialized.
+     */
+    materialized() {
+        return new CTEBuilder({
+            ...this.#props,
+            node: common_table_expression_node_js_1.CommonTableExpressionNode.cloneWith(this.#props.node, {
+                materialized: true,
+            }),
+        });
+    }
+    /**
+     * Makes the common table expression not materialized.
+     */
+    notMaterialized() {
+        return new CTEBuilder({
+            ...this.#props,
+            node: common_table_expression_node_js_1.CommonTableExpressionNode.cloneWith(this.#props.node, {
+                materialized: false,
+            }),
+        });
+    }
+    toOperationNode() {
+        return this.#props.node;
+    }
+}
+exports.CTEBuilder = CTEBuilder;