kysely 0.9.2 → 0.9.6

package/dist/cjs/operation-node/operation-node-visitor.js

@@ -62,327 +62,12 @@ class OperationNodeVisitor {
         AddConstraintNode: this.visitAddConstraint.bind(this),
         DropConstraintNode: this.visitDropConstraint.bind(this),
         ForeignKeyConstraintNode: this.visitForeignKeyConstraint.bind(this),
+        UnionNode: this.visitUnion.bind(this),
     };
     visitNode = (node) => {
         this.nodeStack.push(node);
         this.#visitors[node.kind](node);
         this.nodeStack.pop();
     };
-    visitSelectQuery(node) {
-        if (node.with) {
-            this.visitNode(node.with);
-        }
-        if (node.distinctOnSelections) {
-            node.distinctOnSelections.forEach(this.visitNode);
-        }
-        if (node.selections) {
-            node.selections.forEach(this.visitNode);
-        }
-        this.visitNode(node.from);
-        if (node.joins) {
-            node.joins.forEach(this.visitNode);
-        }
-        if (node.where) {
-            this.visitNode(node.where);
-        }
-        if (node.groupBy) {
-            this.visitNode(node.groupBy);
-        }
-        if (node.having) {
-            this.visitNode(node.having);
-        }
-        if (node.orderBy) {
-            this.visitNode(node.orderBy);
-        }
-        if (node.limit) {
-            this.visitNode(node.limit);
-        }
-        if (node.offset) {
-            this.visitNode(node.offset);
-        }
-    }
-    visitSelection(node) {
-        this.visitNode(node.selection);
-    }
-    visitColumn(node) {
-        this.visitNode(node.column);
-    }
-    visitAlias(node) {
-        this.visitNode(node.node);
-    }
-    visitTable(node) {
-        if (node.schema) {
-            this.visitNode(node.schema);
-        }
-        this.visitNode(node.table);
-    }
-    visitFrom(node) {
-        node.froms.forEach(this.visitNode);
-    }
-    visitReference(node) {
-        this.visitNode(node.column);
-        this.visitNode(node.table);
-    }
-    visitFilter(node) {
-        if (node.left) {
-            this.visitNode(node.left);
-        }
-        this.visitNode(node.op);
-        this.visitNode(node.right);
-    }
-    visitAnd(node) {
-        this.visitNode(node.left);
-        this.visitNode(node.right);
-    }
-    visitOr(node) {
-        this.visitNode(node.left);
-        this.visitNode(node.right);
-    }
-    visitValueList(node) {
-        node.values.forEach(this.visitNode);
-    }
-    visitParens(node) {
-        this.visitNode(node.node);
-    }
-    visitJoin(node) {
-        this.visitNode(node.table);
-        if (node.on) {
-            this.visitNode(node.on);
-        }
-    }
-    visitRaw(node) {
-        node.params.forEach(this.visitNode);
-    }
-    visitWhere(node) {
-        this.visitNode(node.where);
-    }
-    visitInsertQuery(node) {
-        if (node.with) {
-            this.visitNode(node.with);
-        }
-        this.visitNode(node.into);
-        if (node.columns) {
-            node.columns.forEach(this.visitNode);
-        }
-        if (node.values) {
-            node.values.forEach(this.visitNode);
-        }
-        if (node.returning) {
-            this.visitNode(node.returning);
-        }
-    }
-    visitDeleteQuery(node) {
-        if (node.with) {
-            this.visitNode(node.with);
-        }
-        this.visitNode(node.from);
-        if (node.joins) {
-            node.joins.forEach(this.visitNode);
-        }
-        if (node.where) {
-            this.visitNode(node.where);
-        }
-        if (node.returning) {
-            this.visitNode(node.returning);
-        }
-    }
-    visitReturning(node) {
-        node.selections.forEach(this.visitNode);
-    }
-    visitCreateTable(node) {
-        this.visitNode(node.table);
-        node.columns.forEach(this.visitNode);
-        if (node.constraints) {
-            node.constraints.forEach(this.visitNode);
-        }
-    }
-    visitAddColumn(node) {
-        this.visitNode(node.column);
-    }
-    visitColumnDefinition(node) {
-        this.visitNode(node.column);
-        this.visitNode(node.dataType);
-        if (node.defaultTo) {
-            this.visitNode(node.defaultTo);
-        }
-        if (node.references) {
-            this.visitNode(node.references);
-        }
-        if (node.check) {
-            this.visitNode(node.check);
-        }
-    }
-    visitDropTable(node) {
-        this.visitNode(node.table);
-    }
-    visitOrderBy(node) {
-        node.items.forEach(this.visitNode);
-    }
-    visitOrderByItem(node) {
-        this.visitNode(node.orderBy);
-    }
-    visitGroupBy(node) {
-        node.items.forEach(this.visitNode);
-    }
-    visitGroupByItem(node) {
-        this.visitNode(node.groupBy);
-    }
-    visitUpdateQuery(node) {
-        if (node.with) {
-            this.visitNode(node.with);
-        }
-        this.visitNode(node.table);
-        if (node.updates) {
-            node.updates.forEach(this.visitNode);
-        }
-        if (node.joins) {
-            node.joins.forEach(this.visitNode);
-        }
-        if (node.where) {
-            this.visitNode(node.where);
-        }
-        if (node.returning) {
-            this.visitNode(node.returning);
-        }
-    }
-    visitColumnUpdate(node) {
-        this.visitNode(node.column);
-        this.visitNode(node.value);
-    }
-    visitLimit(node) {
-        this.visitNode(node.limit);
-    }
-    visitOffset(node) {
-        this.visitNode(node.offset);
-    }
-    visitOnConflict(node) {
-        if (node.columns) {
-            node.columns.forEach(this.visitNode);
-        }
-        if (node.constraint) {
-            this.visitNode(node.constraint);
-        }
-        if (node.updates) {
-            node.updates.forEach(this.visitNode);
-        }
-    }
-    visitOnDuplicateKey(node) {
-        node.updates.forEach(this.visitNode);
-    }
-    visitCreateIndex(node) {
-        this.visitNode(node.name);
-        if (node.table) {
-            this.visitNode(node.table);
-        }
-        if (node.using) {
-            this.visitNode(node.using);
-        }
-        if (node.expression) {
-            this.visitNode(node.expression);
-        }
-    }
-    visitList(node) {
-        node.items.forEach(this.visitNode);
-    }
-    visitDropIndex(node) {
-        this.visitNode(node.name);
-        if (node.table) {
-            this.visitNode(node.table);
-        }
-    }
-    visitPrimaryKeyConstraint(node) {
-        if (node.name) {
-            this.visitNode(node.name);
-        }
-        node.columns.forEach(this.visitNode);
-    }
-    visitUniqueConstraint(node) {
-        if (node.name) {
-            this.visitNode(node.name);
-        }
-        node.columns.forEach(this.visitNode);
-    }
-    visitReferences(node) {
-        node.columns.forEach(this.visitNode);
-        this.visitNode(node.table);
-    }
-    visitCheckConstraint(node) {
-        if (node.name) {
-            this.visitNode(node.name);
-        }
-        this.visitNode(node.expression);
-    }
-    visitWith(node) {
-        node.expressions.forEach(this.visitNode);
-    }
-    visitCommonTableExpression(node) {
-        this.visitNode(node.name);
-        this.visitNode(node.expression);
-    }
-    visitHaving(node) {
-        this.visitNode(node.having);
-    }
-    visitCreateSchema(node) {
-        this.visitNode(node.schema);
-    }
-    visitDropSchema(node) {
-        this.visitNode(node.schema);
-    }
-    visitAlterTable(node) {
-        this.visitNode(node.table);
-        if (node.renameTo) {
-            this.visitNode(node.renameTo);
-        }
-        if (node.renameColumn) {
-            this.visitNode(node.renameColumn);
-        }
-        if (node.setSchema) {
-            this.visitNode(node.setSchema);
-        }
-        if (node.addColumn) {
-            this.visitNode(node.addColumn);
-        }
-        if (node.dropColumn) {
-            this.visitNode(node.dropColumn);
-        }
-        if (node.alterColumn) {
-            this.visitNode(node.alterColumn);
-        }
-        if (node.modifyColumn) {
-            this.visitNode(node.modifyColumn);
-        }
-    }
-    visitDropColumn(node) {
-        this.visitNode(node.column);
-    }
-    visitRenameColumn(node) {
-        this.visitNode(node.column);
-        this.visitNode(node.renameTo);
-    }
-    visitAlterColumn(node) {
-        this.visitNode(node.column);
-    }
-    visitModifyColumn(node) {
-        this.visitNode(node.column);
-    }
-    visitAddConstraint(node) {
-        this.visitNode(node.constraint);
-    }
-    visitDropConstraint(node) {
-        this.visitNode(node.constraintName);
-    }
-    visitForeignKeyConstraint(node) {
-        if (node.name) {
-            this.visitNode(node.name);
-        }
-        node.columns.forEach(this.visitNode);
-        this.visitNode(node.references);
-    }
-    visitDataType(node) { }
-    visitSelectAll(_) { }
-    visitIdentifier(_) { }
-    visitValue(_) { }
-    visitPrimitiveValueList(_) { }
-    visitOperator(node) { }
 }
 exports.OperationNodeVisitor = OperationNodeVisitor;

package/dist/cjs/operation-node/operation-node.d.ts

@@ -1,4 +1,4 @@
-export declare type OperationNodeKind = 'IdentifierNode' | 'RawNode' | 'SelectQueryNode' | 'SelectionNode' | 'ReferenceNode' | 'ColumnNode' | 'TableNode' | 'AliasNode' | 'FromNode' | 'SelectAllNode' | 'FilterNode' | 'AndNode' | 'OrNode' | 'ParensNode' | 'ValueNode' | 'ValueListNode' | 'PrimitiveValueListNode' | 'JoinNode' | 'OperatorNode' | 'WhereNode' | 'InsertQueryNode' | 'DeleteQueryNode' | 'ReturningNode' | 'CreateTableNode' | 'ColumnDefinitionNode' | 'AddColumnNode' | 'DropTableNode' | 'DataTypeNode' | 'OrderByNode' | 'OrderByItemNode' | 'GroupByNode' | 'GroupByItemNode' | 'UpdateQueryNode' | 'ColumnUpdateNode' | 'LimitNode' | 'OffsetNode' | 'OnConflictNode' | 'OnDuplicateKeyNode' | 'CreateIndexNode' | 'DropIndexNode' | 'ListNode' | 'ReferencesNode' | 'PrimaryKeyConstraintNode' | 'UniqueConstraintNode' | 'CheckConstraintNode' | 'ForeignKeyConstraintNode' | 'WithNode' | 'CommonTableExpressionNode' | 'HavingNode' | 'CreateSchemaNode' | 'DropSchemaNode' | 'AlterTableNode' | 'ModifyColumnNode' | 'DropColumnNode' | 'RenameColumnNode' | 'AlterColumnNode' | 'AddConstraintNode' | 'DropConstraintNode';
+export declare type OperationNodeKind = 'IdentifierNode' | 'RawNode' | 'SelectQueryNode' | 'SelectionNode' | 'ReferenceNode' | 'ColumnNode' | 'TableNode' | 'AliasNode' | 'FromNode' | 'SelectAllNode' | 'FilterNode' | 'AndNode' | 'OrNode' | 'ParensNode' | 'ValueNode' | 'ValueListNode' | 'PrimitiveValueListNode' | 'JoinNode' | 'OperatorNode' | 'WhereNode' | 'InsertQueryNode' | 'DeleteQueryNode' | 'ReturningNode' | 'CreateTableNode' | 'ColumnDefinitionNode' | 'AddColumnNode' | 'DropTableNode' | 'DataTypeNode' | 'OrderByNode' | 'OrderByItemNode' | 'GroupByNode' | 'GroupByItemNode' | 'UpdateQueryNode' | 'ColumnUpdateNode' | 'LimitNode' | 'OffsetNode' | 'OnConflictNode' | 'OnDuplicateKeyNode' | 'CreateIndexNode' | 'DropIndexNode' | 'ListNode' | 'ReferencesNode' | 'PrimaryKeyConstraintNode' | 'UniqueConstraintNode' | 'CheckConstraintNode' | 'ForeignKeyConstraintNode' | 'WithNode' | 'CommonTableExpressionNode' | 'HavingNode' | 'CreateSchemaNode' | 'DropSchemaNode' | 'AlterTableNode' | 'ModifyColumnNode' | 'DropColumnNode' | 'RenameColumnNode' | 'AlterColumnNode' | 'AddConstraintNode' | 'DropConstraintNode' | 'UnionNode';
 export interface OperationNode {
     readonly kind: OperationNodeKind;
 }

package/dist/cjs/operation-node/operator-node.d.ts

@@ -1,6 +1,6 @@
 import { ArrayItemType } from '../util/type-utils.js';
 import { OperationNode } from './operation-node.js';
-export declare const OPERATORS: readonly ["=", "==", "!=", "<>", ">", ">=", "<", "<=", "in", "not in", "is", "is not", "like", "not like", "ilike", "not ilike", "@>", "<@", "?", "?", "?&", "!<", "!>", "<=>", "!~", "~", "~*", "!~*", "exists", "not exists"];
+export declare const OPERATORS: readonly ["=", "==", "!=", "<>", ">", ">=", "<", "<=", "in", "not in", "is", "is not", "like", "not like", "ilike", "not ilike", "@>", "<@", "?", "?", "?&", "!<", "!>", "<=>", "!~", "~", "~*", "!~*", "exists", "not exists", "&&"];
 export declare type Operator = ArrayItemType<typeof OPERATORS>;
 export interface OperatorNode extends OperationNode {
     readonly kind: 'OperatorNode';

package/dist/cjs/operation-node/operator-node.js

@@ -33,6 +33,7 @@ exports.OPERATORS = [
     '!~*',
     'exists',
     'not exists',
+    '&&',
 ];
 /**
  * @internal

package/dist/cjs/operation-node/select-query-node.d.ts

@@ -12,6 +12,7 @@ import { OrderByNode } from './order-by-node.js';
 import { SelectionNode } from './selection-node.js';
 import { WhereNode } from './where-node.js';
 import { WithNode } from './with-node.js';
+import { UnionNode } from './union-node.js';
 export declare type SelectModifier = 'ForUpdate' | 'ForNoKeyUpdate' | 'ForShare' | 'ForKeyShare' | 'NoWait' | 'SkipLocked';
 export interface SelectQueryNode extends OperationNode {
     readonly kind: 'SelectQueryNode';
@@ -28,6 +29,7 @@ export interface SelectQueryNode extends OperationNode {
     readonly offset?: OffsetNode;
     readonly with?: WithNode;
     readonly having?: HavingNode;
+    readonly union?: ReadonlyArray<UnionNode>;
 }
 /**
  * @internal
@@ -45,4 +47,5 @@ export declare const SelectQueryNode: Readonly<{
     cloneWithHaving(selectNode: SelectQueryNode, filter: HavingNodeChild): SelectQueryNode;
     cloneWithOrHaving(selectNode: SelectQueryNode, filter: HavingNodeChild): SelectQueryNode;
     cloneWithDistinct(selectNode: SelectQueryNode): SelectQueryNode;
+    cloneWithUnion(selectNode: SelectQueryNode, union: UnionNode): SelectQueryNode;
 }>;

package/dist/cjs/operation-node/select-query-node.js

@@ -94,4 +94,12 @@ exports.SelectQueryNode = (0, object_utils_js_1.freeze)({
             isDistinct: true,
         });
     },
+    cloneWithUnion(selectNode, union) {
+        return (0, object_utils_js_1.freeze)({
+            ...selectNode,
+            union: selectNode.union
+                ? (0, object_utils_js_1.freeze)([...selectNode.union, union])
+                : (0, object_utils_js_1.freeze)([union]),
+        });
+    },
 });

package/dist/cjs/operation-node/union-node.d.ts

@@ -0,0 +1,16 @@
+import { OperationNode } from './operation-node.js';
+import { RawNode } from './raw-node.js';
+import { SelectQueryNode } from './select-query-node.js';
+export declare type UnionExpressionNode = SelectQueryNode | RawNode;
+export interface UnionNode extends OperationNode {
+    readonly kind: 'UnionNode';
+    readonly union: UnionExpressionNode;
+    readonly all: boolean;
+}
+/**
+ * @internal
+ */
+export declare const UnionNode: Readonly<{
+    is(node: OperationNode): node is UnionNode;
+    create(union: UnionExpressionNode, all: boolean): UnionNode;
+}>;

package/dist/cjs/operation-node/union-node.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnionNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+/**
+ * @internal
+ */
+exports.UnionNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'UnionNode';
+    },
+    create(union, all) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'UnionNode',
+            union,
+            all,
+        });
+    },
+});

package/dist/cjs/parser/insert-values-parser.d.ts

@@ -8,7 +8,7 @@ import { PrimitiveValue } from '../util/object-utils.js';
 export declare type InsertObject<DB, TB extends keyof DB> = {
     [C in keyof DB[TB]]: InsertValueExpression<DB[TB][C]>;
 };
-export declare type InsertObjectOrList<DB, TB extends keyof DB> = InsertObject<DB, TB> | InsertObject<DB, TB>[];
+export declare type InsertObjectOrList<DB, TB extends keyof DB> = InsertObject<DB, TB> | ReadonlyArray<InsertObject<DB, TB>>;
 declare type InsertValueExpression<T> = T | AnyQueryBuilder | AnyRawBuilder | GeneratedPlaceholder;
 export declare function parseInsertObjectOrList(args: InsertObjectOrList<any, any>): [ReadonlyArray<ColumnNode>, ReadonlyArray<InsertValuesNode>];
 export declare function parseInsertValueExpression(value: InsertValueExpression<PrimitiveValue>): ValueNode | RawNode | SelectQueryNode;

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

@@ -3,9 +3,9 @@ import { AnyColumn, AnyColumnWithTable } from '../util/type-utils.js';
 import { ExtractAliasFromTableExpression, TableExpressionDatabase } from './table-parser.js';
 import { JoinBuilder } from '../query-builder/join-builder.js';
 import { ParseContext } from './parse-context.js';
-export declare type JoinReferenceExpression<DB, TB extends keyof DB, F> = AnyJoinColumn<DB, TB, F> | AnyJoinColumnWithTable<DB, TB, F>;
-export declare type JoinCallbackExpression<DB, TB extends keyof DB, F> = (join: JoinBuilder<TableExpressionDatabase<DB, F>, TB | ExtractAliasFromTableExpression<DB, F>>) => JoinBuilder<any, any>;
-declare type AnyJoinColumn<DB, TB extends keyof DB, F> = AnyColumn<TableExpressionDatabase<DB, F>, TB | ExtractAliasFromTableExpression<DB, F>>;
-declare type AnyJoinColumnWithTable<DB, TB extends keyof DB, F> = AnyColumnWithTable<TableExpressionDatabase<DB, F>, TB | ExtractAliasFromTableExpression<DB, F>>;
+export declare type JoinReferenceExpression<DB, TB extends keyof DB, TE> = AnyJoinColumn<DB, TB, TE> | AnyJoinColumnWithTable<DB, TB, TE>;
+export declare type JoinCallbackExpression<DB, TB extends keyof DB, TE> = (join: JoinBuilder<TableExpressionDatabase<DB, TE>, TB | ExtractAliasFromTableExpression<DB, TE>>) => JoinBuilder<any, any>;
+declare type AnyJoinColumn<DB, TB extends keyof DB, TE> = AnyColumn<TableExpressionDatabase<DB, TE>, TB | ExtractAliasFromTableExpression<DB, TE>>;
+declare type AnyJoinColumnWithTable<DB, TB extends keyof DB, TE> = AnyColumnWithTable<TableExpressionDatabase<DB, TE>, TB | ExtractAliasFromTableExpression<DB, TE>>;
 export declare function parseJoin(ctx: ParseContext, joinType: JoinType, args: any[]): JoinNode;
 export {};

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

@@ -0,0 +1,5 @@
+import { UnionNode } from '../operation-node/union-node.js';
+import { QueryBuilder } from '../query-builder/query-builder.js';
+import { RawBuilder } from '../raw-builder/raw-builder.js';
+export declare type UnionExpression<DB, O> = QueryBuilder<DB, any, O> | RawBuilder<O>;
+export declare function parseUnion(union: UnionExpression<any, any>, all: boolean): UnionNode;

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

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseUnion = void 0;
+const query_node_js_1 = require("../operation-node/query-node.js");
+const union_node_js_1 = require("../operation-node/union-node.js");
+function parseUnion(union, all) {
+    const node = union.toOperationNode();
+    if (query_node_js_1.QueryNode.isMutating(node)) {
+        throw new Error("can't combine insert, update or delete queries using union");
+    }
+    return union_node_js_1.UnionNode.create(node, all);
+}
+exports.parseUnion = parseUnion;

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

@@ -3,6 +3,6 @@ import { AnyQueryBuilder, AnyRawBuilder, QueryBuilderFactory, RawBuilderFactory
 import { ExtractTypeFromReferenceExpression } from './reference-parser.js';
 import { ParseContext } from './parse-context.js';
 export declare type ValueExpression<DB, TB extends keyof DB, RE> = ExtractTypeFromReferenceExpression<DB, TB, RE> | AnyQueryBuilder | QueryBuilderFactory<DB, TB> | AnyRawBuilder | RawBuilderFactory<DB, TB>;
-export declare type ValueExpressionOrList<DB, TB extends keyof DB, RE> = ValueExpression<DB, TB, RE> | ValueExpression<DB, TB, RE>[];
+export declare type ValueExpressionOrList<DB, TB extends keyof DB, RE> = ValueExpression<DB, TB, RE> | ReadonlyArray<ValueExpression<DB, TB, RE>>;
 export declare function parseValueExpressionOrList(ctx: ParseContext, arg: ValueExpressionOrList<any, any, any>): ValueExpressionNode;
 export declare function parseValueExpression(ctx: ParseContext, arg: ValueExpression<any, any, any>): ValueExpressionNode;

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

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CamelCasePlugin = 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");
+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.
@@ -72,9 +73,9 @@ class CamelCasePlugin {
     #snakeCase;
     #snakeCaseTransformer;
     constructor(opt = {}) {
-        this.#camelCase = createCamelCase(opt);
-        this.#snakeCase = createSnakeCase(opt);
-        this.#snakeCaseTransformer = new SnakeCaseTransformer(this.snakeCase.bind(this));
+        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);
@@ -109,118 +110,6 @@ class CamelCasePlugin {
     }
 }
 exports.CamelCasePlugin = CamelCasePlugin;
-class SnakeCaseTransformer extends operation_node_transformer_js_1.OperationNodeTransformer {
-    #snakeCase;
-    constructor(snakeCase) {
-        super();
-        this.#snakeCase = snakeCase;
-    }
-    transformIdentifier(node) {
-        node = super.transformIdentifier(node);
-        return {
-            ...node,
-            identifier: this.#snakeCase(node.identifier),
-        };
-    }
-}
 function canMap(obj) {
     return (0, object_utils_js_1.isObject)(obj) && !(obj instanceof Date) && !Buffer.isBuffer(obj);
 }
-function createSnakeCase({ 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 += '_' + 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;
-        }
-    });
-}
-function createCamelCase({ 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/camel-case/camel-case-transformer.d.ts

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

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

@@ -0,0 +1,19 @@
+"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) {
+        node = super.transformIdentifier(node);
+        return {
+            ...node,
+            identifier: this.#snakeCase(node.identifier),
+        };
+    }
+}
+exports.SnakeCaseTransformer = SnakeCaseTransformer;

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

@@ -0,0 +1,15 @@
+export declare 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;