kysely 0.28.17 → 0.29.0

package/dist/cjs/parser/with-parser.d.ts

@@ -1,45 +0,0 @@
-import type { UpdateQueryBuilder } from '../query-builder/update-query-builder.js';
-import type { DeleteQueryBuilder } from '../query-builder/delete-query-builder.js';
-import type { InsertQueryBuilder } from '../query-builder/insert-query-builder.js';
-import type { QueryCreator } from '../query-creator.js';
-import type { Expression } from '../expression/expression.js';
-import type { ShallowRecord } from '../util/type-utils.js';
-import { type CTEBuilderCallback } from '../query-builder/cte-builder.js';
-import { CommonTableExpressionNode } from '../operation-node/common-table-expression-node.js';
-export type CommonTableExpression<DB, CN extends string> = (creator: QueryCreator<DB>) => CommonTableExpressionOutput<DB, CN>;
-export type RecursiveCommonTableExpression<DB, CN extends string> = (creator: QueryCreator<DB & {
-    [K in ExtractTableFromCommonTableExpressionName<CN>]: ExtractRowFromCommonTableExpressionName<CN>;
-}>) => CommonTableExpressionOutput<DB, CN>;
-export type QueryCreatorWithCommonTableExpression<DB, CN extends string, CTE> = QueryCreator<DB & {
-    [K in ExtractTableFromCommonTableExpressionName<CN>]: ExtractRowFromCommonTableExpression<CTE>;
-}>;
-type CommonTableExpressionOutput<DB, CN extends string> = Expression<ExtractRowFromCommonTableExpressionName<CN>> | InsertQueryBuilder<DB, any, ExtractRowFromCommonTableExpressionName<CN>> | UpdateQueryBuilder<DB, any, any, ExtractRowFromCommonTableExpressionName<CN>> | DeleteQueryBuilder<DB, any, ExtractRowFromCommonTableExpressionName<CN>>;
-/**
- * Given a common CommonTableExpression CTE extracts the row type from it.
- *
- * For example a CTE `(db) => db.selectFrom('person').select(['id', 'first_name'])`
- * would result in `Pick<Person, 'id' | 'first_name'>`.
- */
-type ExtractRowFromCommonTableExpression<CTE> = CTE extends (creator: QueryCreator<any>) => infer Q ? Q extends Expression<infer QO> ? QO : Q extends InsertQueryBuilder<any, any, infer QO> ? QO : Q extends UpdateQueryBuilder<any, any, any, infer QO> ? QO : Q extends DeleteQueryBuilder<any, any, infer QO> ? QO : never : never;
-/**
- * Extracts 'person' from a string like 'person(id, first_name)'.
- */
-type ExtractTableFromCommonTableExpressionName<CN extends string> = CN extends `${infer TB}(${string})` ? TB : CN;
-/**
- * Parses a string like 'person(id, first_name)' into a type:
- *
- * {
- *   id: any,
- *   first_name: any
- * }
- *
- */
-type ExtractRowFromCommonTableExpressionName<CN extends string> = CN extends `${string}(${infer CL})` ? {
-    [C in ExtractColumnNamesFromColumnList<CL>]: any;
-} : ShallowRecord<string, any>;
-/**
- * Parses a string like 'id, first_name' into a type 'id' | 'first_name'
- */
-type ExtractColumnNamesFromColumnList<R extends string> = R extends `${infer C}, ${infer RS}` ? C | ExtractColumnNamesFromColumnList<RS> : R;
-export declare function parseCommonTableExpression(nameOrBuilderCallback: string | CTEBuilderCallback<string>, expression: CommonTableExpression<any, string>): CommonTableExpressionNode;
-export {};

package/dist/cjs/parser/with-parser.js

@@ -1,33 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseCommonTableExpression = parseCommonTableExpression;
-const common_table_expression_name_node_js_1 = require("../operation-node/common-table-expression-name-node.js");
-const parse_utils_js_1 = require("./parse-utils.js");
-const object_utils_js_1 = require("../util/object-utils.js");
-const cte_builder_js_1 = require("../query-builder/cte-builder.js");
-const common_table_expression_node_js_1 = require("../operation-node/common-table-expression-node.js");
-function parseCommonTableExpression(nameOrBuilderCallback, expression) {
-    const expressionNode = expression((0, parse_utils_js_1.createQueryCreator)()).toOperationNode();
-    if ((0, object_utils_js_1.isFunction)(nameOrBuilderCallback)) {
-        return nameOrBuilderCallback(cteBuilderFactory(expressionNode)).toOperationNode();
-    }
-    return common_table_expression_node_js_1.CommonTableExpressionNode.create(parseCommonTableExpressionName(nameOrBuilderCallback), expressionNode);
-}
-function cteBuilderFactory(expressionNode) {
-    return (name) => {
-        return new cte_builder_js_1.CTEBuilder({
-            node: common_table_expression_node_js_1.CommonTableExpressionNode.create(parseCommonTableExpressionName(name), expressionNode),
-        });
-    };
-}
-function parseCommonTableExpressionName(name) {
-    if (name.includes('(')) {
-        const parts = name.split(/[\(\)]/);
-        const table = parts[0];
-        const columns = parts[1].split(',').map((it) => it.trim());
-        return common_table_expression_name_node_js_1.CommonTableExpressionNameNode.create(table, columns);
-    }
-    else {
-        return common_table_expression_name_node_js_1.CommonTableExpressionNameNode.create(name);
-    }
-}

package/dist/cjs/plugin/camel-case/camel-case-plugin.d.ts

@@ -1,170 +0,0 @@
-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';
-export interface CamelCasePluginOptions {
-    /**
-     * If true, camelCase is transformed into upper case SNAKE_CASE.
-     * For example `fooBar => FOO_BAR` and `FOO_BAR => fooBar`
-     *
-     * Defaults to false.
-     */
-    upperCase?: boolean;
-    /**
-     * If true, an underscore is added before each digit when converting
-     * camelCase to snake_case. For example `foo12Bar => foo_12_bar` and
-     * `foo_12_bar => foo12Bar`
-     *
-     * Defaults to false.
-     */
-    underscoreBeforeDigits?: boolean;
-    /**
-     * If true, an underscore is added between consecutive upper case
-     * letters when converting from camelCase to snake_case. For example
-     * `fooBAR => foo_b_a_r` and `foo_b_a_r => fooBAR`.
-     *
-     * Defaults to false.
-     */
-    underscoreBetweenUppercaseLetters?: boolean;
-    /**
-     * If true, nested object's keys will not be converted to camel case.
-     *
-     * Defaults to false.
-     */
-    maintainNestedObjectKeys?: boolean;
-}
-/**
- * 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 declare class CamelCasePlugin implements KyselyPlugin {
-    #private;
-    readonly opt: CamelCasePluginOptions;
-    constructor(opt?: CamelCasePluginOptions);
-    /**
-     * 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>>;
-    protected mapRow(row: UnknownRow): UnknownRow;
-    protected snakeCase(str: string): string;
-    protected camelCase(str: string): string;
-}

package/dist/cjs/plugin/camel-case/camel-case-plugin.js

@@ -1,122 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CamelCasePlugin = void 0;
-const object_utils_js_1 = require("../../util/object-utils.js");
-const camel_case_transformer_js_1 = require("./camel-case-transformer.js");
-const camel_case_js_1 = require("./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
- *   }
- * }
- * ```
- */
-class CamelCasePlugin {
-    opt;
-    #camelCase;
-    #snakeCase;
-    #snakeCaseTransformer;
-    constructor(opt = {}) {
-        this.opt = opt;
-        this.#camelCase = (0, camel_case_js_1.createCamelCaseMapper)(opt);
-        this.#snakeCase = (0, camel_case_js_1.createSnakeCaseMapper)(opt);
-        this.#snakeCaseTransformer = new camel_case_transformer_js_1.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);
-    }
-}
-exports.CamelCasePlugin = CamelCasePlugin;
-function canMap(obj, opt) {
-    return (0, object_utils_js_1.isPlainObject)(obj) && !opt?.maintainNestedObjectKeys;
-}

package/dist/cjs/plugin/camel-case/camel-case-transformer.js

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SnakeCaseTransformer = void 0;
-const operation_node_transformer_js_1 = require("../../operation-node/operation-node-transformer.js");
-class SnakeCaseTransformer extends operation_node_transformer_js_1.OperationNodeTransformer {
-    #snakeCase;
-    constructor(snakeCase) {
-        super();
-        this.#snakeCase = snakeCase;
-    }
-    transformIdentifier(node, queryId) {
-        node = super.transformIdentifier(node, queryId);
-        return {
-            ...node,
-            name: this.#snakeCase(node.name),
-        };
-    }
-}
-exports.SnakeCaseTransformer = SnakeCaseTransformer;

package/dist/cjs/plugin/camel-case/camel-case.js

@@ -1,111 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createSnakeCaseMapper = createSnakeCaseMapper;
-exports.createCamelCaseMapper = createCamelCaseMapper;
-/**
- * Creates a function that transforms camel case strings to snake case.
- */
-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.
- */
-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/cjs/plugin/deduplicate-joins/deduplicate-joins-plugin.d.ts

@@ -1,70 +0,0 @@
-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/cjs/plugin/deduplicate-joins/deduplicate-joins-plugin.js

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DeduplicateJoinsPlugin = void 0;
-const deduplicate_joins_transformer_js_1 = require("./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)
- */
-class DeduplicateJoinsPlugin {
-    #transformer = new deduplicate_joins_transformer_js_1.DeduplicateJoinsTransformer();
-    transformQuery(args) {
-        return this.#transformer.transformNode(args.node, args.queryId);
-    }
-    transformResult(args) {
-        return Promise.resolve(args.result);
-    }
-}
-exports.DeduplicateJoinsPlugin = DeduplicateJoinsPlugin;

package/dist/cjs/plugin/deduplicate-joins/deduplicate-joins-transformer.js

@@ -1,42 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DeduplicateJoinsTransformer = void 0;
-const operation_node_transformer_js_1 = require("../../operation-node/operation-node-transformer.js");
-const object_utils_js_1 = require("../../util/object-utils.js");
-class DeduplicateJoinsTransformer extends operation_node_transformer_js_1.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 (0, object_utils_js_1.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 ((0, object_utils_js_1.compare)(joins[i], out[j])) {
-                    foundDuplicate = true;
-                    break;
-                }
-            }
-            if (!foundDuplicate) {
-                out.push(joins[i]);
-            }
-        }
-        return (0, object_utils_js_1.freeze)(out);
-    }
-}
-exports.DeduplicateJoinsTransformer = DeduplicateJoinsTransformer;