@decocms/mesh 1.0.0-alpha.1

package/dist/server/node_modules/kysely/dist/esm/plugin/camel-case/camel-case-plugin.js

@@ -0,0 +1,119 @@
+/// <reference types="./camel-case-plugin.d.ts" />
+import { isPlainObject } from '../../util/object-utils.js';
+import { SnakeCaseTransformer } from './camel-case-transformer.js';
+import { createCamelCaseMapper, createSnakeCaseMapper, } from './camel-case.js';
+/**
+ * A plugin that converts snake_case identifiers in the database into
+ * camelCase in the JavaScript side.
+ *
+ * For example let's assume we have a table called `person_table`
+ * with columns `first_name` and `last_name` in the database. When
+ * using `CamelCasePlugin` we would setup Kysely like this:
+ *
+ * ```ts
+ * import * as Sqlite from 'better-sqlite3'
+ * import { CamelCasePlugin, Kysely, SqliteDialect } from 'kysely'
+ *
+ * interface CamelCasedDatabase {
+ *   userMetadata: {
+ *     firstName: string
+ *     lastName: string
+ *   }
+ * }
+ *
+ * const db = new Kysely<CamelCasedDatabase>({
+ *   dialect: new SqliteDialect({
+ *     database: new Sqlite(':memory:'),
+ *   }),
+ *   plugins: [new CamelCasePlugin()],
+ * })
+ *
+ * const person = await db.selectFrom('userMetadata')
+ *   .where('firstName', '=', 'Arnold')
+ *   .select(['firstName', 'lastName'])
+ *   .executeTakeFirst()
+ *
+ * if (person) {
+ *   console.log(person.firstName)
+ * }
+ * ```
+ *
+ * The generated SQL (SQLite):
+ *
+ * ```sql
+ * select "first_name", "last_name" from "user_metadata" where "first_name" = ?
+ * ```
+ *
+ * As you can see from the example, __everything__ needs to be defined
+ * in camelCase in the TypeScript code: table names, columns, schemas,
+ * __everything__. When using the `CamelCasePlugin` Kysely works as if
+ * the database was defined in camelCase.
+ *
+ * There are various options you can give to the plugin to modify
+ * the way identifiers are converted. See {@link CamelCasePluginOptions}.
+ * If those options are not enough, you can override this plugin's
+ * `snakeCase` and `camelCase` methods to make the conversion exactly
+ * the way you like:
+ *
+ * ```ts
+ * class MyCamelCasePlugin extends CamelCasePlugin {
+ *   protected override snakeCase(str: string): string {
+ *     // ...
+ *
+ *     return str
+ *   }
+ *
+ *   protected override camelCase(str: string): string {
+ *     // ...
+ *
+ *     return str
+ *   }
+ * }
+ * ```
+ */
+export class CamelCasePlugin {
+    opt;
+    #camelCase;
+    #snakeCase;
+    #snakeCaseTransformer;
+    constructor(opt = {}) {
+        this.opt = opt;
+        this.#camelCase = createCamelCaseMapper(opt);
+        this.#snakeCase = createSnakeCaseMapper(opt);
+        this.#snakeCaseTransformer = new SnakeCaseTransformer(this.snakeCase.bind(this));
+    }
+    transformQuery(args) {
+        return this.#snakeCaseTransformer.transformNode(args.node, args.queryId);
+    }
+    async transformResult(args) {
+        if (args.result.rows && Array.isArray(args.result.rows)) {
+            return {
+                ...args.result,
+                rows: args.result.rows.map((row) => this.mapRow(row)),
+            };
+        }
+        return args.result;
+    }
+    mapRow(row) {
+        return Object.keys(row).reduce((obj, key) => {
+            let value = row[key];
+            if (Array.isArray(value)) {
+                value = value.map((it) => (canMap(it, this.opt) ? this.mapRow(it) : it));
+            }
+            else if (canMap(value, this.opt)) {
+                value = this.mapRow(value);
+            }
+            obj[this.camelCase(key)] = value;
+            return obj;
+        }, {});
+    }
+    snakeCase(str) {
+        return this.#snakeCase(str);
+    }
+    camelCase(str) {
+        return this.#camelCase(str);
+    }
+}
+function canMap(obj, opt) {
+    return isPlainObject(obj) && !opt?.maintainNestedObjectKeys;
+}

package/dist/server/node_modules/kysely/dist/esm/plugin/camel-case/camel-case-transformer.d.ts

@@ -0,0 +1,9 @@
+import type { IdentifierNode } from '../../operation-node/identifier-node.js';
+import { OperationNodeTransformer } from '../../operation-node/operation-node-transformer.js';
+import type { QueryId } from '../../util/query-id.js';
+import type { StringMapper } from './camel-case.js';
+export declare class SnakeCaseTransformer extends OperationNodeTransformer {
+    #private;
+    constructor(snakeCase: StringMapper);
+    protected transformIdentifier(node: IdentifierNode, queryId: QueryId): IdentifierNode;
+}

package/dist/server/node_modules/kysely/dist/esm/plugin/camel-case/camel-case-transformer.js

@@ -0,0 +1,16 @@
+/// <reference types="./camel-case-transformer.d.ts" />
+import { OperationNodeTransformer } from '../../operation-node/operation-node-transformer.js';
+export class SnakeCaseTransformer extends OperationNodeTransformer {
+    #snakeCase;
+    constructor(snakeCase) {
+        super();
+        this.#snakeCase = snakeCase;
+    }
+    transformIdentifier(node, queryId) {
+        node = super.transformIdentifier(node, queryId);
+        return {
+            ...node,
+            name: this.#snakeCase(node.name),
+        };
+    }
+}

package/dist/server/node_modules/kysely/dist/esm/plugin/camel-case/camel-case.d.ts

@@ -0,0 +1,15 @@
+export type StringMapper = (str: string) => string;
+/**
+ * Creates a function that transforms camel case strings to snake case.
+ */
+export declare function createSnakeCaseMapper({ upperCase, underscoreBeforeDigits, underscoreBetweenUppercaseLetters, }?: {
+    upperCase?: boolean | undefined;
+    underscoreBeforeDigits?: boolean | undefined;
+    underscoreBetweenUppercaseLetters?: boolean | undefined;
+}): StringMapper;
+/**
+ * Creates a function that transforms snake case strings to camel case.
+ */
+export declare function createCamelCaseMapper({ upperCase, }?: {
+    upperCase?: boolean | undefined;
+}): StringMapper;

package/dist/server/node_modules/kysely/dist/esm/plugin/camel-case/camel-case.js

@@ -0,0 +1,108 @@
+/// <reference types="./camel-case.d.ts" />
+/**
+ * Creates a function that transforms camel case strings to snake case.
+ */
+export function createSnakeCaseMapper({ upperCase = false, underscoreBeforeDigits = false, underscoreBetweenUppercaseLetters = false, } = {}) {
+    return memoize((str) => {
+        if (str.length === 0) {
+            return str;
+        }
+        const upper = str.toUpperCase();
+        const lower = str.toLowerCase();
+        let out = lower[0];
+        for (let i = 1, l = str.length; i < l; ++i) {
+            const char = str[i];
+            const prevChar = str[i - 1];
+            const upperChar = upper[i];
+            const prevUpperChar = upper[i - 1];
+            const lowerChar = lower[i];
+            const prevLowerChar = lower[i - 1];
+            // If underScoreBeforeDigits is true then, well, insert an underscore
+            // before digits :). Only the first digit gets an underscore if
+            // there are multiple.
+            if (underscoreBeforeDigits &&
+                isDigit(char) &&
+                !isDigit(prevChar) &&
+                !out.endsWith('_')) {
+                out += '_' + char;
+                continue;
+            }
+            // Test if `char` is an upper-case character and that the character
+            // actually has different upper and lower case versions.
+            if (char === upperChar && upperChar !== lowerChar) {
+                const prevCharacterIsUppercase = prevChar === prevUpperChar && prevUpperChar !== prevLowerChar;
+                // If underscoreBetweenUppercaseLetters is true, we always place an underscore
+                // before consecutive uppercase letters (e.g. "fooBAR" becomes "foo_b_a_r").
+                // Otherwise, we don't (e.g. "fooBAR" becomes "foo_bar").
+                if (underscoreBetweenUppercaseLetters || !prevCharacterIsUppercase) {
+                    out += '_' + lowerChar;
+                }
+                else {
+                    out += lowerChar;
+                }
+            }
+            else {
+                out += char;
+            }
+        }
+        if (upperCase) {
+            return out.toUpperCase();
+        }
+        else {
+            return out;
+        }
+    });
+}
+/**
+ * Creates a function that transforms snake case strings to camel case.
+ */
+export function createCamelCaseMapper({ upperCase = false, } = {}) {
+    return memoize((str) => {
+        if (str.length === 0) {
+            return str;
+        }
+        if (upperCase && isAllUpperCaseSnakeCase(str)) {
+            // Only convert to lower case if the string is all upper
+            // case snake_case. This allows camelCase strings to go
+            // through without changing.
+            str = str.toLowerCase();
+        }
+        let out = str[0];
+        for (let i = 1, l = str.length; i < l; ++i) {
+            const char = str[i];
+            const prevChar = str[i - 1];
+            if (char !== '_') {
+                if (prevChar === '_') {
+                    out += char.toUpperCase();
+                }
+                else {
+                    out += char;
+                }
+            }
+        }
+        return out;
+    });
+}
+function isAllUpperCaseSnakeCase(str) {
+    for (let i = 1, l = str.length; i < l; ++i) {
+        const char = str[i];
+        if (char !== '_' && char !== char.toUpperCase()) {
+            return false;
+        }
+    }
+    return true;
+}
+function isDigit(char) {
+    return char >= '0' && char <= '9';
+}
+function memoize(func) {
+    const cache = new Map();
+    return (str) => {
+        let mapped = cache.get(str);
+        if (!mapped) {
+            mapped = func(str);
+            cache.set(str, mapped);
+        }
+        return mapped;
+    };
+}

package/dist/server/node_modules/kysely/dist/esm/plugin/deduplicate-joins/deduplicate-joins-plugin.d.ts

@@ -0,0 +1,70 @@
+import type { QueryResult } from '../../driver/database-connection.js';
+import type { RootOperationNode } from '../../query-compiler/query-compiler.js';
+import type { UnknownRow } from '../../util/type-utils.js';
+import type { KyselyPlugin, PluginTransformQueryArgs, PluginTransformResultArgs } from '../kysely-plugin.js';
+/**
+ * Plugin that removes duplicate joins from queries.
+ *
+ * See [this recipe](https://github.com/kysely-org/kysely/blob/master/site/docs/recipes/0008-deduplicate-joins.md)
+ */
+export declare class DeduplicateJoinsPlugin implements KyselyPlugin {
+    #private;
+    /**
+     * This is called for each query before it is executed. You can modify the query by
+     * transforming its {@link OperationNode} tree provided in {@link PluginTransformQueryArgs.node | args.node}
+     * and returning the transformed tree. You'd usually want to use an {@link OperationNodeTransformer}
+     * for this.
+     *
+     * If you need to pass some query-related data between this method and `transformResult` you
+     * can use a `WeakMap` with {@link PluginTransformQueryArgs.queryId | args.queryId} as the key:
+     *
+     * ```ts
+     * import type {
+     *   KyselyPlugin,
+     *   QueryResult,
+     *   RootOperationNode,
+     *   UnknownRow
+     * } from 'kysely'
+     *
+     * interface MyData {
+     *   // ...
+     * }
+     * const data = new WeakMap<any, MyData>()
+     *
+     * const plugin = {
+     *   transformQuery(args: PluginTransformQueryArgs): RootOperationNode {
+     *     const something: MyData = {}
+     *
+     *     // ...
+     *
+     *     data.set(args.queryId, something)
+     *
+     *     // ...
+     *
+     *     return args.node
+     *   },
+     *
+     *   async transformResult(args: PluginTransformResultArgs): Promise<QueryResult<UnknownRow>> {
+     *     // ...
+     *
+     *     const something = data.get(args.queryId)
+     *
+     *     // ...
+     *
+     *     return args.result
+     *   }
+     * } satisfies KyselyPlugin
+     * ```
+     *
+     * You should use a `WeakMap` instead of a `Map` or some other strong references because `transformQuery`
+     * is not always matched by a call to `transformResult` which would leave orphaned items in the map
+     * and cause a memory leak.
+     */
+    transformQuery(args: PluginTransformQueryArgs): RootOperationNode;
+    /**
+     * This method is called for each query after it has been executed. The result
+     * of the query can be accessed through {@link PluginTransformResultArgs.result | args.result}.
+     * You can modify the result and return the modifier result.
+     */
+    transformResult(args: PluginTransformResultArgs): Promise<QueryResult<UnknownRow>>;
+}

package/dist/server/node_modules/kysely/dist/esm/plugin/deduplicate-joins/deduplicate-joins-plugin.js

@@ -0,0 +1,16 @@
+/// <reference types="./deduplicate-joins-plugin.d.ts" />
+import { DeduplicateJoinsTransformer } from './deduplicate-joins-transformer.js';
+/**
+ * Plugin that removes duplicate joins from queries.
+ *
+ * See [this recipe](https://github.com/kysely-org/kysely/blob/master/site/docs/recipes/0008-deduplicate-joins.md)
+ */
+export class DeduplicateJoinsPlugin {
+    #transformer = new DeduplicateJoinsTransformer();
+    transformQuery(args) {
+        return this.#transformer.transformNode(args.node, args.queryId);
+    }
+    transformResult(args) {
+        return Promise.resolve(args.result);
+    }
+}

package/dist/server/node_modules/kysely/dist/esm/plugin/deduplicate-joins/deduplicate-joins-transformer.d.ts

@@ -0,0 +1,11 @@
+import type { DeleteQueryNode } from '../../operation-node/delete-query-node.js';
+import { OperationNodeTransformer } from '../../operation-node/operation-node-transformer.js';
+import type { SelectQueryNode } from '../../operation-node/select-query-node.js';
+import type { UpdateQueryNode } from '../../operation-node/update-query-node.js';
+import type { QueryId } from '../../util/query-id.js';
+export declare class DeduplicateJoinsTransformer extends OperationNodeTransformer {
+    #private;
+    protected transformSelectQuery(node: SelectQueryNode, queryId: QueryId): SelectQueryNode;
+    protected transformUpdateQuery(node: UpdateQueryNode, queryId: QueryId): UpdateQueryNode;
+    protected transformDeleteQuery(node: DeleteQueryNode, queryId: QueryId): DeleteQueryNode;
+}

package/dist/server/node_modules/kysely/dist/esm/plugin/deduplicate-joins/deduplicate-joins-transformer.js

@@ -0,0 +1,39 @@
+/// <reference types="./deduplicate-joins-transformer.d.ts" />
+import { OperationNodeTransformer } from '../../operation-node/operation-node-transformer.js';
+import { compare, freeze } from '../../util/object-utils.js';
+export class DeduplicateJoinsTransformer extends OperationNodeTransformer {
+    transformSelectQuery(node, queryId) {
+        return this.#transformQuery(super.transformSelectQuery(node, queryId));
+    }
+    transformUpdateQuery(node, queryId) {
+        return this.#transformQuery(super.transformUpdateQuery(node, queryId));
+    }
+    transformDeleteQuery(node, queryId) {
+        return this.#transformQuery(super.transformDeleteQuery(node, queryId));
+    }
+    #transformQuery(node) {
+        if (!node.joins || node.joins.length === 0) {
+            return node;
+        }
+        return freeze({
+            ...node,
+            joins: this.#deduplicateJoins(node.joins),
+        });
+    }
+    #deduplicateJoins(joins) {
+        const out = [];
+        for (let i = 0; i < joins.length; ++i) {
+            let foundDuplicate = false;
+            for (let j = 0; j < out.length; ++j) {
+                if (compare(joins[i], out[j])) {
+                    foundDuplicate = true;
+                    break;
+                }
+            }
+            if (!foundDuplicate) {
+                out.push(joins[i]);
+            }
+        }
+        return freeze(out);
+    }
+}

package/dist/server/node_modules/kysely/dist/esm/plugin/handle-empty-in-lists/handle-empty-in-lists-plugin.d.ts

@@ -0,0 +1,211 @@
+import type { QueryResult } from '../../driver/database-connection.js';
+import type { RootOperationNode } from '../../query-compiler/query-compiler.js';
+import type { KyselyPlugin, PluginTransformQueryArgs, PluginTransformResultArgs } from '../kysely-plugin.js';
+import type { UnknownRow } from '../../util/type-utils.js';
+import type { HandleEmptyInListsOptions } from './handle-empty-in-lists.js';
+/**
+ * A plugin that allows handling `in ()` and `not in ()` expressions.
+ *
+ * These expressions are invalid SQL syntax for many databases, and result in runtime
+ * database errors.
+ *
+ * The workarounds used by other libraries always involve modifying the query under
+ * the hood, which is not aligned with Kysely's philosophy of WYSIWYG. We recommend manually checking
+ * for empty arrays before passing them as arguments to `in` and `not in` expressions
+ * instead, but understand that this can be cumbersome. Hence we're going with an
+ * opt-in approach where you can choose if and how to handle these cases. We do
+ * not want to make this the default behavior, as it can lead to unexpected behavior.
+ * Use it at your own risk. Test it. Make sure it works as expected for you.
+ *
+ * Using this plugin also allows you to throw an error (thus avoiding unnecessary
+ * requests to the database) or print a warning in these cases.
+ *
+ * ### Examples
+ *
+ * The following strategy replaces the `in`/`not in` expression with a noncontingent
+ * expression. A contradiction (falsy) `1 = 0` for `in`, and a tautology (truthy) `1 = 1` for `not in`),
+ * similarily to how {@link https://github.com/knex/knex/blob/176151d8048b2a7feeb89a3d649a5580786d4f4e/docs/src/guide/query-builder.md#L1763 | Knex.js},
+ * {@link https://github.com/prisma/prisma-engines/blob/99168c54187178484dae45d9478aa40cfd1866d2/quaint/src/visitor.rs#L804-L823 | PrismaORM},
+ * {@link https://github.com/laravel/framework/blob/8.x/src/Illuminate/Database/Query/Grammars/Grammar.php#L284-L291 | Laravel},
+ * {@link https://docs.sqlalchemy.org/en/13/core/engines.html#sqlalchemy.create_engine.params.empty_in_strategy | SQLAlchemy}
+ * handle this.
+ *
+ * ```ts
+ * import Sqlite from 'better-sqlite3'
+ * import {
+ *   HandleEmptyInListsPlugin,
+ *   Kysely,
+ *   replaceWithNoncontingentExpression,
+ *   SqliteDialect,
+ * } from 'kysely'
+ * import type { Database } from 'type-editor' // imaginary module
+ *
+ * const db = new Kysely<Database>({
+ *   dialect: new SqliteDialect({
+ *     database: new Sqlite(':memory:'),
+ *   }),
+ *   plugins: [
+ *     new HandleEmptyInListsPlugin({
+ *       strategy: replaceWithNoncontingentExpression
+ *     })
+ *   ],
+ * })
+ *
+ * const results = await db
+ *   .selectFrom('person')
+ *   .where('id', 'in', [])
+ *   .where('first_name', 'not in', [])
+ *   .selectAll()
+ *   .execute()
+ * ```
+ *
+ * The generated SQL (SQLite):
+ *
+ * ```sql
+ * select * from "person" where 1 = 0 and 1 = 1
+ * ```
+ *
+ * The following strategy does the following:
+ *
+ * When `in`, pushes a `null` value into the empty list resulting in `in (null)`,
+ * similiarly to how {@link https://github.com/typeorm/typeorm/blob/0280cdc451c35ef73c830eb1191c95d34f6ce06e/src/query-builder/QueryBuilder.ts#L919-L922 | TypeORM}
+ * and {@link https://github.com/sequelize/sequelize/blob/0f2891c6897e12bf9bf56df344aae5b698f58c7d/packages/core/src/abstract-dialect/where-sql-builder.ts#L368-L379 | Sequelize}
+ * handle `in ()`. `in (null)` is logically the equivalent of `= null`, which returns
+ * `null`, which is a falsy expression in most SQL databases. We recommend NOT
+ * using this strategy if you plan to use `in` in `select`, `returning`, or `output`
+ * clauses, as the return type differs from the `SqlBool` default type for comparisons.
+ *
+ * When `not in`, casts the left operand as `char` and pushes a unique value into
+ * the empty list resulting in `cast({{lhs}} as char) not in ({{VALUE}})`. Casting
+ * is required to avoid database errors with non-string values.
+ *
+ * ```ts
+ * import Sqlite from 'better-sqlite3'
+ * import {
+ *   HandleEmptyInListsPlugin,
+ *   Kysely,
+ *   pushValueIntoList,
+ *   SqliteDialect
+ * } from 'kysely'
+ * import type { Database } from 'type-editor' // imaginary module
+ *
+ * const db = new Kysely<Database>({
+ *   dialect: new SqliteDialect({
+ *     database: new Sqlite(':memory:'),
+ *   }),
+ *   plugins: [
+ *     new HandleEmptyInListsPlugin({
+ *       strategy: pushValueIntoList('__kysely_no_values_were_provided__') // choose a unique value for not in. has to be something with zero chance being in the data.
+ *     })
+ *   ],
+ * })
+ *
+ * const results = await db
+ *   .selectFrom('person')
+ *   .where('id', 'in', [])
+ *   .where('first_name', 'not in', [])
+ *   .selectAll()
+ *   .execute()
+ * ```
+ *
+ * The generated SQL (SQLite):
+ *
+ * ```sql
+ * select * from "person" where "id" in (null) and cast("first_name" as char) not in ('__kysely_no_values_were_provided__')
+ * ```
+ *
+ * The following custom strategy throws an error when an empty list is encountered
+ * to avoid unnecessary requests to the database:
+ *
+ * ```ts
+ * import Sqlite from 'better-sqlite3'
+ * import {
+ *   HandleEmptyInListsPlugin,
+ *   Kysely,
+ *   SqliteDialect
+ * } from 'kysely'
+ * import type { Database } from 'type-editor' // imaginary module
+ *
+ * const db = new Kysely<Database>({
+ *   dialect: new SqliteDialect({
+ *     database: new Sqlite(':memory:'),
+ *   }),
+ *   plugins: [
+ *     new HandleEmptyInListsPlugin({
+ *       strategy: () => {
+ *         throw new Error('Empty in/not-in is not allowed')
+ *       }
+ *     })
+ *   ],
+ * })
+ *
+ * const results = await db
+ *   .selectFrom('person')
+ *   .where('id', 'in', [])
+ *   .selectAll()
+ *   .execute() // throws an error with 'Empty in/not-in is not allowed' message!
+ * ```
+ */
+export declare class HandleEmptyInListsPlugin implements KyselyPlugin {
+    #private;
+    readonly opt: HandleEmptyInListsOptions;
+    constructor(opt: HandleEmptyInListsOptions);
+    /**
+     * This is called for each query before it is executed. You can modify the query by
+     * transforming its {@link OperationNode} tree provided in {@link PluginTransformQueryArgs.node | args.node}
+     * and returning the transformed tree. You'd usually want to use an {@link OperationNodeTransformer}
+     * for this.
+     *
+     * If you need to pass some query-related data between this method and `transformResult` you
+     * can use a `WeakMap` with {@link PluginTransformQueryArgs.queryId | args.queryId} as the key:
+     *
+     * ```ts
+     * import type {
+     *   KyselyPlugin,
+     *   QueryResult,
+     *   RootOperationNode,
+     *   UnknownRow
+     * } from 'kysely'
+     *
+     * interface MyData {
+     *   // ...
+     * }
+     * const data = new WeakMap<any, MyData>()
+     *
+     * const plugin = {
+     *   transformQuery(args: PluginTransformQueryArgs): RootOperationNode {
+     *     const something: MyData = {}
+     *
+     *     // ...
+     *
+     *     data.set(args.queryId, something)
+     *
+     *     // ...
+     *
+     *     return args.node
+     *   },
+     *
+     *   async transformResult(args: PluginTransformResultArgs): Promise<QueryResult<UnknownRow>> {
+     *     // ...
+     *
+     *     const something = data.get(args.queryId)
+     *
+     *     // ...
+     *
+     *     return args.result
+     *   }
+     * } satisfies KyselyPlugin
+     * ```
+     *
+     * You should use a `WeakMap` instead of a `Map` or some other strong references because `transformQuery`
+     * is not always matched by a call to `transformResult` which would leave orphaned items in the map
+     * and cause a memory leak.
+     */
+    transformQuery(args: PluginTransformQueryArgs): RootOperationNode;
+    /**
+     * This method is called for each query after it has been executed. The result
+     * of the query can be accessed through {@link PluginTransformResultArgs.result | args.result}.
+     * You can modify the result and return the modifier result.
+     */
+    transformResult(args: PluginTransformResultArgs): Promise<QueryResult<UnknownRow>>;
+}