@decocms/mesh 1.0.0-alpha.1

package/dist/server/node_modules/kysely/dist/esm/expression/expression-wrapper.js

@@ -0,0 +1,128 @@
+/// <reference types="./expression-wrapper.d.ts" />
+import { AliasNode } from '../operation-node/alias-node.js';
+import { AndNode } from '../operation-node/and-node.js';
+import { IdentifierNode } from '../operation-node/identifier-node.js';
+import { isOperationNodeSource } from '../operation-node/operation-node-source.js';
+import { OrNode } from '../operation-node/or-node.js';
+import { ParensNode } from '../operation-node/parens-node.js';
+import { parseValueBinaryOperationOrExpression, } from '../parser/binary-operation-parser.js';
+export class ExpressionWrapper {
+    #node;
+    constructor(node) {
+        this.#node = node;
+    }
+    /** @private */
+    get expressionType() {
+        return undefined;
+    }
+    as(alias) {
+        return new AliasedExpressionWrapper(this, alias);
+    }
+    or(...args) {
+        return new OrWrapper(OrNode.create(this.#node, parseValueBinaryOperationOrExpression(args)));
+    }
+    and(...args) {
+        return new AndWrapper(AndNode.create(this.#node, parseValueBinaryOperationOrExpression(args)));
+    }
+    /**
+     * Change the output type of the expression.
+     *
+     * This method call doesn't change the SQL in any way. This methods simply
+     * returns a copy of this `ExpressionWrapper` with a new output type.
+     */
+    $castTo() {
+        return new ExpressionWrapper(this.#node);
+    }
+    /**
+     * 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 ExpressionWrapper(this.#node);
+    }
+    toOperationNode() {
+        return this.#node;
+    }
+}
+export class AliasedExpressionWrapper {
+    #expr;
+    #alias;
+    constructor(expr, alias) {
+        this.#expr = expr;
+        this.#alias = alias;
+    }
+    /** @private */
+    get expression() {
+        return this.#expr;
+    }
+    /** @private */
+    get alias() {
+        return this.#alias;
+    }
+    toOperationNode() {
+        return AliasNode.create(this.#expr.toOperationNode(), isOperationNodeSource(this.#alias)
+            ? this.#alias.toOperationNode()
+            : IdentifierNode.create(this.#alias));
+    }
+}
+export class OrWrapper {
+    #node;
+    constructor(node) {
+        this.#node = node;
+    }
+    /** @private */
+    get expressionType() {
+        return undefined;
+    }
+    as(alias) {
+        return new AliasedExpressionWrapper(this, alias);
+    }
+    or(...args) {
+        return new OrWrapper(OrNode.create(this.#node, parseValueBinaryOperationOrExpression(args)));
+    }
+    /**
+     * Change the output type of the expression.
+     *
+     * This method call doesn't change the SQL in any way. This methods simply
+     * returns a copy of this `OrWrapper` with a new output type.
+     */
+    $castTo() {
+        return new OrWrapper(this.#node);
+    }
+    toOperationNode() {
+        return ParensNode.create(this.#node);
+    }
+}
+export class AndWrapper {
+    #node;
+    constructor(node) {
+        this.#node = node;
+    }
+    /** @private */
+    get expressionType() {
+        return undefined;
+    }
+    as(alias) {
+        return new AliasedExpressionWrapper(this, alias);
+    }
+    and(...args) {
+        return new AndWrapper(AndNode.create(this.#node, parseValueBinaryOperationOrExpression(args)));
+    }
+    /**
+     * Change the output type of the expression.
+     *
+     * This method call doesn't change the SQL in any way. This methods simply
+     * returns a copy of this `AndWrapper` with a new output type.
+     */
+    $castTo() {
+        return new AndWrapper(this.#node);
+    }
+    toOperationNode() {
+        return ParensNode.create(this.#node);
+    }
+}

package/dist/server/node_modules/kysely/dist/esm/expression/expression.d.ts

@@ -0,0 +1,198 @@
+import type { AliasNode } from '../operation-node/alias-node.js';
+import { type OperationNodeSource } from '../operation-node/operation-node-source.js';
+import type { OperationNode } from '../operation-node/operation-node.js';
+/**
+ * `Expression` represents an arbitrary SQL expression with a type.
+ *
+ * Most Kysely methods accept instances of `Expression` and most classes like `SelectQueryBuilder`
+ * and the return value of the {@link sql} template tag implement it.
+ *
+ * ### Examples
+ *
+ * ```ts
+ * import { type Expression, sql } from 'kysely'
+ *
+ * const exp1: Expression<string> = sql<string>`CONCAT('hello', ' ', 'world')`
+ * const exp2: Expression<{ first_name: string }> = db.selectFrom('person').select('first_name')
+ * ```
+ *
+ * You can implement the `Expression` interface to create your own type-safe utilities for Kysely.
+ */
+export interface Expression<T> extends OperationNodeSource {
+    /**
+     * All expressions need to have this getter for complicated type-related reasons.
+     * Simply add this getter for your expression and always return `undefined` from it:
+     *
+     * ### Examples
+     *
+     * ```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()
+     *   }
+     * }
+     * ```
+     *
+     * The getter is needed to make the expression assignable to another expression only
+     * if the types `T` are assignable. Without this property (or some other property
+     * that references `T`), you could assing `Expression<string>` to `Expression<number>`.
+     */
+    get expressionType(): T | undefined;
+    /**
+     * 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(): OperationNode;
+}
+/**
+ * An expression with an `as` method.
+ */
+export interface AliasableExpression<T> extends Expression<T> {
+    /**
+     * Returns an aliased version of the expression.
+     *
+     * ### Examples
+     *
+     * In addition to slapping `as "the_alias"` at the end of the expression,
+     * this method also provides strict typing:
+     *
+     * ```ts
+     * const result = await db
+     *   .selectFrom('person')
+     *   .select((eb) =>
+     *     // `eb.fn<string>` returns an AliasableExpression<string>
+     *     eb.fn<string>('concat', ['first_name', eb.val(' '), 'last_name']).as('full_name')
+     *   )
+     *   .executeTakeFirstOrThrow()
+     *
+     * // `full_name: string` field exists in the result type.
+     * console.log(result.full_name)
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select
+     *   concat("first_name", $1, "last_name") as "full_name"
+     * from
+     *   "person"
+     * ```
+     *
+     * You can also pass in a raw SQL snippet (or any expression) but in that case you must
+     * provide the alias as the only type argument:
+     *
+     * ```ts
+     * import { sql } from 'kysely'
+     *
+     * const values = sql<{ a: number, b: string }>`(values (1, 'foo'))`
+     *
+     * // The alias is `t(a, b)` which specifies the column names
+     * // in addition to the table name. We must tell kysely that
+     * // columns of the table can be referenced through `t`
+     * // by providing an explicit type argument.
+     * const aliasedValues = values.as<'t'>(sql`t(a, b)`)
+     *
+     * await db
+     *   .insertInto('person')
+     *   .columns(['first_name', 'last_name'])
+     *   .expression(
+     *     db.selectFrom(aliasedValues).select(['t.a', 't.b'])
+     *   )
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * insert into "person" ("first_name", "last_name")
+     * from (values (1, 'foo')) as t(a, b)
+     * select "t"."a", "t"."b"
+     * ```
+     */
+    as<A extends string>(alias: A): AliasedExpression<T, A>;
+    as<A extends string>(alias: Expression<any>): AliasedExpression<T, A>;
+}
+/**
+ * A type that holds an expression and an alias for it.
+ *
+ * `AliasedExpression<T, A>` can be used in places where, in addition to the value type `T`, you
+ * also need a name `A` for that value. For example anything you can pass into the `select` method
+ * needs to implement an `AliasedExpression<T, A>`. `A` becomes the name of the selected expression
+ * in the result and `T` becomes its type.
+ *
+ * ### Examples
+ *
+ * ```ts
+ * import {
+ *   AliasNode,
+ *   type AliasedExpression,
+ *   type Expression,
+ *   IdentifierNode
+ * } from 'kysely'
+ *
+ * class SomeAliasedExpression<T, A extends string> implements AliasedExpression<T, A> {
+ *   #expression: Expression<T>
+ *   #alias: A
+ *
+ *   constructor(expression: Expression<T>, alias: A) {
+ *     this.#expression = expression
+ *     this.#alias = alias
+ *   }
+ *
+ *   get expression(): Expression<T> {
+ *     return this.#expression
+ *   }
+ *
+ *   get alias(): A {
+ *     return this.#alias
+ *   }
+ *
+ *   toOperationNode(): AliasNode {
+ *     return AliasNode.create(
+ *       this.#expression.toOperationNode(),
+ *       IdentifierNode.create(this.#alias)
+ *     )
+ *   }
+ * }
+ * ```
+ */
+export interface AliasedExpression<T, A extends string> extends OperationNodeSource {
+    /**
+     * Returns the aliased expression.
+     */
+    get expression(): Expression<T>;
+    /**
+     * Returns the alias.
+     */
+    get alias(): A | Expression<unknown>;
+    /**
+     * Creates the OperationNode that describes how to compile this expression into SQL.
+     */
+    toOperationNode(): AliasNode;
+}
+export declare function isExpression(obj: unknown): obj is Expression<any>;
+export declare function isAliasedExpression(obj: unknown): obj is AliasedExpression<any, any>;

package/dist/server/node_modules/kysely/dist/esm/expression/expression.js

@@ -0,0 +1,12 @@
+/// <reference types="./expression.d.ts" />
+import { isOperationNodeSource, } from '../operation-node/operation-node-source.js';
+import { isObject, isString } from '../util/object-utils.js';
+export function isExpression(obj) {
+    return isObject(obj) && 'expressionType' in obj && isOperationNodeSource(obj);
+}
+export function isAliasedExpression(obj) {
+    return (isObject(obj) &&
+        'expression' in obj &&
+        isString(obj.alias) &&
+        isOperationNodeSource(obj));
+}

package/dist/server/node_modules/kysely/dist/esm/helpers/mssql.d.ts

@@ -0,0 +1,212 @@
+import type { Expression } from '../expression/expression.js';
+import type { RawBuilder } from '../raw-builder/raw-builder.js';
+import type { ShallowDehydrateObject, ShallowDehydrateValue, Simplify } from '../util/type-utils.js';
+/**
+ * An MS SQL Server helper for aggregating a subquery into a JSON array.
+ *
+ * NOTE: This helper only works correctly if you've installed the `ParseJSONResultsPlugin`.
+ * Otherwise the nested selections will be returned as JSON strings.
+ *
+ * The plugin can be installed like this:
+ *
+ * ```ts
+ * import { Kysely, MssqlDialect, ParseJSONResultsPlugin } from 'kysely'
+ * import * as Tarn from 'tarn'
+ * import * as Tedious from 'tedious'
+ * import type { Database } from 'type-editor' // imaginary module
+ *
+ * const db = new Kysely<Database>({
+ *   dialect: new MssqlDialect({
+ *     tarn: { options: { max: 10, min: 0 }, ...Tarn },
+ *     tedious: {
+ *       ...Tedious,
+ *       connectionFactory: () => new Tedious.Connection({
+ *         authentication: {
+ *           options: { password: 'password', userName: 'sa' },
+ *           type: 'default',
+ *         },
+ *         options: { database: 'test', port: 21433, trustServerCertificate: true },
+ *         server: 'localhost',
+ *       }),
+ *     },
+ *   }),
+ *   plugins: [new ParseJSONResultsPlugin()]
+ * })
+ * ```
+ *
+ * ### Examples
+ *
+ * ```ts
+ * import { jsonArrayFrom } from 'kysely/helpers/mssql'
+ *
+ * const result = await db
+ *   .selectFrom('person')
+ *   .select((eb) => [
+ *     'id',
+ *     jsonArrayFrom(
+ *       eb.selectFrom('pet')
+ *         .select(['pet.id as pet_id', 'pet.name'])
+ *         .whereRef('pet.owner_id', '=', 'person.id')
+ *         .orderBy('pet.name')
+ *         .offset(0)
+ *     ).as('pets')
+ *   ])
+ *   .execute()
+ *
+ * result[0]?.id
+ * result[0]?.pets[0]?.pet_id
+ * result[0]?.pets[0]?.name
+ * ```
+ *
+ * The generated SQL (MS SQL Server):
+ *
+ * ```sql
+ * select "id", (
+ *   select coalesce((select * from (
+ *     select "pet"."id" as "pet_id", "pet"."name"
+ *     from "pet"
+ *     where "pet"."owner_id" = "person"."id"
+ *     order by "pet"."name"
+ *     offset @1 rows
+ *   ) as "agg" for json path, include_null_values), '[]')
+ * ) as "pets"
+ * from "person"
+ * ```
+ */
+export declare function jsonArrayFrom<O>(expr: Expression<O>): RawBuilder<Simplify<ShallowDehydrateObject<O>>[]>;
+/**
+ * An MS SQL Server helper for turning a subquery into a JSON object.
+ *
+ * The subquery must only return one row.
+ *
+ * NOTE: This helper only works correctly if you've installed the `ParseJSONResultsPlugin`.
+ * Otherwise the nested selections will be returned as JSON strings.
+ *
+ * The plugin can be installed like this:
+ *
+ * ```ts
+ * import { Kysely, MssqlDialect, ParseJSONResultsPlugin } from 'kysely'
+ * import * as Tarn from 'tarn'
+ * import * as Tedious from 'tedious'
+ * import type { Database } from 'type-editor' // imaginary module
+ *
+ * const db = new Kysely<Database>({
+ *   dialect: new MssqlDialect({
+ *     tarn: { options: { max: 10, min: 0 }, ...Tarn },
+ *     tedious: {
+ *       ...Tedious,
+ *       connectionFactory: () => new Tedious.Connection({
+ *         authentication: {
+ *           options: { password: 'password', userName: 'sa' },
+ *           type: 'default',
+ *         },
+ *         options: { database: 'test', port: 21433, trustServerCertificate: true },
+ *         server: 'localhost',
+ *       }),
+ *     },
+ *   }),
+ *   plugins: [new ParseJSONResultsPlugin()]
+ * })
+ * ```
+ *
+ * ### Examples
+ *
+ * ```ts
+ * import { jsonObjectFrom } from 'kysely/helpers/mssql'
+ *
+ * const result = await db
+ *   .selectFrom('person')
+ *   .select((eb) => [
+ *     'id',
+ *     jsonObjectFrom(
+ *       eb.selectFrom('pet')
+ *         .select(['pet.id as pet_id', 'pet.name'])
+ *         .whereRef('pet.owner_id', '=', 'person.id')
+ *         .where('pet.is_favorite', '=', 1)
+ *     ).as('favorite_pet')
+ *   ])
+ *   .execute()
+ *
+ * result[0]?.id
+ * result[0]?.favorite_pet?.pet_id
+ * result[0]?.favorite_pet?.name
+ * ```
+ *
+ * The generated SQL (MS SQL Server):
+ *
+ * ```sql
+ * select "id", (
+ *   select * from (
+ *     select "pet"."id" as "pet_id", "pet"."name"
+ *     from "pet"
+ *     where "pet"."owner_id" = "person"."id"
+ *     and "pet"."is_favorite" = @1
+ *   ) as "agg" for json path, include_null_values, without_array_wrapper
+ * ) as "favorite_pet"
+ * from "person"
+ * ```
+ */
+export declare function jsonObjectFrom<O>(expr: Expression<O>): RawBuilder<Simplify<ShallowDehydrateObject<O>> | null>;
+/**
+ * The MS SQL Server `json_query` function, single argument variant.
+ *
+ * NOTE: This helper only works correctly if you've installed the `ParseJSONResultsPlugin`.
+ * Otherwise the nested selections will be returned as JSON strings.
+ *
+ * The plugin can be installed like this:
+ *
+ * ```ts
+ * import { Kysely, MssqlDialect, ParseJSONResultsPlugin } from 'kysely'
+ * import * as Tarn from 'tarn'
+ * import * as Tedious from 'tedious'
+ * import type { Database } from 'type-editor' // imaginary module
+ *
+ * const db = new Kysely<Database>({
+ *   dialect: new MssqlDialect({
+ *     tarn: { options: { max: 10, min: 0 }, ...Tarn },
+ *     tedious: {
+ *       ...Tedious,
+ *       connectionFactory: () => new Tedious.Connection({
+ *         authentication: {
+ *           options: { password: 'password', userName: 'sa' },
+ *           type: 'default',
+ *         },
+ *         options: { database: 'test', port: 21433, trustServerCertificate: true },
+ *         server: 'localhost',
+ *       }),
+ *     },
+ *   }),
+ *   plugins: [new ParseJSONResultsPlugin()]
+ * })
+ * ```
+ *
+ * ### Examples
+ *
+ * ```ts
+ * import { jsonBuildObject } from 'kysely/helpers/mssql'
+ *
+ * const result = await db
+ *   .selectFrom('person')
+ *   .select((eb) => [
+ *     'id',
+ *     jsonBuildObject({
+ *       first: eb.ref('first_name'),
+ *       last: eb.ref('last_name'),
+ *       full: eb.fn('concat', ['first_name', eb.val(' '), 'last_name'])
+ *     }).as('name')
+ *   ])
+ *   .execute()
+ * ```
+ *
+ * The generated SQL (MS SQL Server):
+ *
+ * ```sql
+ * select "id", json_query(
+ *   '{"first":"'+"first_name"+',"last":"'+"last_name"+',"full":"'+concat("first_name", ' ', "last_name")+'"}'
+ * ) as "name"
+ * from "person"
+ * ```
+ */
+export declare function jsonBuildObject<O extends Record<string, Expression<unknown>>>(obj: O): RawBuilder<Simplify<{
+    [K in keyof O]: O[K] extends Expression<infer V> ? ShallowDehydrateValue<V> : never;
+}>>;