@decocms/mesh 1.0.0-alpha.1

package/dist/server/node_modules/kysely/dist/cjs/operation-node/add-index-node.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AddIndexNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+const identifier_node_js_1 = require("./identifier-node.js");
+/**
+ * @internal
+ */
+exports.AddIndexNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'AddIndexNode';
+    },
+    create(name) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'AddIndexNode',
+            name: identifier_node_js_1.IdentifierNode.create(name),
+        });
+    },
+    cloneWith(node, props) {
+        return (0, object_utils_js_1.freeze)({
+            ...node,
+            ...props,
+        });
+    },
+    cloneWithColumns(node, columns) {
+        return (0, object_utils_js_1.freeze)({
+            ...node,
+            columns: [...(node.columns || []), ...columns],
+        });
+    },
+});

package/dist/server/node_modules/kysely/dist/cjs/operation-node/aggregate-function-node.d.ts

@@ -0,0 +1,29 @@
+import type { OperationNode } from './operation-node.js';
+import type { OverNode } from './over-node.js';
+import { WhereNode } from './where-node.js';
+import { OrderByNode } from './order-by-node.js';
+import type { OrderByItemNode } from './order-by-item-node.js';
+export interface AggregateFunctionNode extends OperationNode {
+    readonly kind: 'AggregateFunctionNode';
+    readonly func: string;
+    readonly aggregated: readonly OperationNode[];
+    readonly distinct?: boolean;
+    readonly orderBy?: OrderByNode;
+    readonly withinGroup?: OrderByNode;
+    readonly filter?: WhereNode;
+    readonly over?: OverNode;
+}
+type AggregateFunctionNodeFactory = Readonly<{
+    is(node: OperationNode): node is AggregateFunctionNode;
+    create(aggregateFunction: string, aggregated?: readonly OperationNode[]): Readonly<AggregateFunctionNode>;
+    cloneWithDistinct(aggregateFunctionNode: AggregateFunctionNode): Readonly<AggregateFunctionNode>;
+    cloneWithOrderBy(aggregateFunctionNode: AggregateFunctionNode, orderItems: ReadonlyArray<OrderByItemNode>, withinGroup?: boolean): Readonly<AggregateFunctionNode>;
+    cloneWithFilter(aggregateFunctionNode: AggregateFunctionNode, filter: OperationNode): Readonly<AggregateFunctionNode>;
+    cloneWithOrFilter(aggregateFunctionNode: AggregateFunctionNode, filter: OperationNode): Readonly<AggregateFunctionNode>;
+    cloneWithOver(aggregateFunctionNode: AggregateFunctionNode, over?: OverNode): Readonly<AggregateFunctionNode>;
+}>;
+/**
+ * @internal
+ */
+export declare const AggregateFunctionNode: AggregateFunctionNodeFactory;
+export {};

package/dist/server/node_modules/kysely/dist/cjs/operation-node/aggregate-function-node.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AggregateFunctionNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+const where_node_js_1 = require("./where-node.js");
+const order_by_node_js_1 = require("./order-by-node.js");
+/**
+ * @internal
+ */
+exports.AggregateFunctionNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'AggregateFunctionNode';
+    },
+    create(aggregateFunction, aggregated = []) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'AggregateFunctionNode',
+            func: aggregateFunction,
+            aggregated,
+        });
+    },
+    cloneWithDistinct(aggregateFunctionNode) {
+        return (0, object_utils_js_1.freeze)({
+            ...aggregateFunctionNode,
+            distinct: true,
+        });
+    },
+    cloneWithOrderBy(aggregateFunctionNode, orderItems, withinGroup = false) {
+        const prop = withinGroup ? 'withinGroup' : 'orderBy';
+        return (0, object_utils_js_1.freeze)({
+            ...aggregateFunctionNode,
+            [prop]: aggregateFunctionNode[prop]
+                ? order_by_node_js_1.OrderByNode.cloneWithItems(aggregateFunctionNode[prop], orderItems)
+                : order_by_node_js_1.OrderByNode.create(orderItems),
+        });
+    },
+    cloneWithFilter(aggregateFunctionNode, filter) {
+        return (0, object_utils_js_1.freeze)({
+            ...aggregateFunctionNode,
+            filter: aggregateFunctionNode.filter
+                ? where_node_js_1.WhereNode.cloneWithOperation(aggregateFunctionNode.filter, 'And', filter)
+                : where_node_js_1.WhereNode.create(filter),
+        });
+    },
+    cloneWithOrFilter(aggregateFunctionNode, filter) {
+        return (0, object_utils_js_1.freeze)({
+            ...aggregateFunctionNode,
+            filter: aggregateFunctionNode.filter
+                ? where_node_js_1.WhereNode.cloneWithOperation(aggregateFunctionNode.filter, 'Or', filter)
+                : where_node_js_1.WhereNode.create(filter),
+        });
+    },
+    cloneWithOver(aggregateFunctionNode, over) {
+        return (0, object_utils_js_1.freeze)({
+            ...aggregateFunctionNode,
+            over,
+        });
+    },
+});

package/dist/server/node_modules/kysely/dist/cjs/operation-node/alias-node.d.ts

@@ -0,0 +1,15 @@
+import type { OperationNode } from './operation-node.js';
+export interface AliasNode extends OperationNode {
+    readonly kind: 'AliasNode';
+    readonly node: OperationNode;
+    readonly alias: OperationNode;
+}
+type AliasNodeFactory = Readonly<{
+    is(node: OperationNode): node is AliasNode;
+    create(node: OperationNode, alias: OperationNode): Readonly<AliasNode>;
+}>;
+/**
+ * @internal
+ */
+export declare const AliasNode: AliasNodeFactory;
+export {};

package/dist/server/node_modules/kysely/dist/cjs/operation-node/alias-node.js

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

package/dist/server/node_modules/kysely/dist/cjs/operation-node/alter-column-node.d.ts

@@ -0,0 +1,23 @@
+import type { OperationNode } from './operation-node.js';
+import { ColumnNode } from './column-node.js';
+import type { RawNode } from './raw-node.js';
+export type AlterColumnNodeProps = Omit<AlterColumnNode, 'kind' | 'column'>;
+export interface AlterColumnNode extends OperationNode {
+    readonly kind: 'AlterColumnNode';
+    readonly column: ColumnNode;
+    readonly dataType?: OperationNode;
+    readonly dataTypeExpression?: RawNode;
+    readonly setDefault?: OperationNode;
+    readonly dropDefault?: true;
+    readonly setNotNull?: true;
+    readonly dropNotNull?: true;
+}
+type AlterColumnNodeFactory = Readonly<{
+    is(node: OperationNode): node is AlterColumnNode;
+    create<T extends keyof AlterColumnNodeProps>(column: string, prop: T, value: Required<AlterColumnNodeProps>[T]): Readonly<AlterColumnNode>;
+}>;
+/**
+ * @internal
+ */
+export declare const AlterColumnNode: AlterColumnNodeFactory;
+export {};

package/dist/server/node_modules/kysely/dist/cjs/operation-node/alter-column-node.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AlterColumnNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+const column_node_js_1 = require("./column-node.js");
+/**
+ * @internal
+ */
+exports.AlterColumnNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'AlterColumnNode';
+    },
+    create(column, prop, value) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'AlterColumnNode',
+            column: column_node_js_1.ColumnNode.create(column),
+            [prop]: value,
+        });
+    },
+});

package/dist/server/node_modules/kysely/dist/cjs/operation-node/alter-table-node.d.ts

@@ -0,0 +1,38 @@
+import type { OperationNode } from './operation-node.js';
+import type { AddColumnNode } from './add-column-node.js';
+import type { DropColumnNode } from './drop-column-node.js';
+import type { TableNode } from './table-node.js';
+import type { IdentifierNode } from './identifier-node.js';
+import type { RenameColumnNode } from './rename-column-node.js';
+import type { AlterColumnNode } from './alter-column-node.js';
+import type { AddConstraintNode } from './add-constraint-node.js';
+import type { DropConstraintNode } from './drop-constraint-node.js';
+import type { ModifyColumnNode } from './modify-column-node.js';
+import type { DropIndexNode } from './drop-index-node.js';
+import type { AddIndexNode } from './add-index-node.js';
+import type { RenameConstraintNode } from './rename-constraint-node.js';
+export type AlterTableNodeTableProps = Pick<AlterTableNode, 'renameTo' | 'setSchema' | 'addConstraint' | 'dropConstraint' | 'addIndex' | 'dropIndex' | 'renameConstraint'>;
+export type AlterTableColumnAlterationNode = RenameColumnNode | AddColumnNode | DropColumnNode | AlterColumnNode | ModifyColumnNode;
+export interface AlterTableNode extends OperationNode {
+    readonly kind: 'AlterTableNode';
+    readonly table: TableNode;
+    readonly renameTo?: TableNode;
+    readonly setSchema?: IdentifierNode;
+    readonly columnAlterations?: ReadonlyArray<AlterTableColumnAlterationNode>;
+    readonly addConstraint?: AddConstraintNode;
+    readonly dropConstraint?: DropConstraintNode;
+    readonly renameConstraint?: RenameConstraintNode;
+    readonly addIndex?: AddIndexNode;
+    readonly dropIndex?: DropIndexNode;
+}
+type AlterTableNodeFactory = Readonly<{
+    is(node: OperationNode): node is AlterTableNode;
+    create(table: TableNode): Readonly<AlterTableNode>;
+    cloneWithTableProps(node: AlterTableNode, props: AlterTableNodeTableProps): Readonly<AlterTableNode>;
+    cloneWithColumnAlteration(node: AlterTableNode, columnAlteration: AlterTableColumnAlterationNode): Readonly<AlterTableNode>;
+}>;
+/**
+ * @internal
+ */
+export declare const AlterTableNode: AlterTableNodeFactory;
+export {};

package/dist/server/node_modules/kysely/dist/cjs/operation-node/alter-table-node.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AlterTableNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+/**
+ * @internal
+ */
+exports.AlterTableNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'AlterTableNode';
+    },
+    create(table) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'AlterTableNode',
+            table,
+        });
+    },
+    cloneWithTableProps(node, props) {
+        return (0, object_utils_js_1.freeze)({
+            ...node,
+            ...props,
+        });
+    },
+    cloneWithColumnAlteration(node, columnAlteration) {
+        return (0, object_utils_js_1.freeze)({
+            ...node,
+            columnAlterations: node.columnAlterations
+                ? [...node.columnAlterations, columnAlteration]
+                : [columnAlteration],
+        });
+    },
+});

package/dist/server/node_modules/kysely/dist/cjs/operation-node/and-node.d.ts

@@ -0,0 +1,15 @@
+import type { OperationNode } from './operation-node.js';
+export interface AndNode extends OperationNode {
+    readonly kind: 'AndNode';
+    readonly left: OperationNode;
+    readonly right: OperationNode;
+}
+type AndNodeFactory = Readonly<{
+    is(node: OperationNode): node is AndNode;
+    create(left: OperationNode, right: OperationNode): Readonly<AndNode>;
+}>;
+/**
+ * @internal
+ */
+export declare const AndNode: AndNodeFactory;
+export {};

package/dist/server/node_modules/kysely/dist/cjs/operation-node/and-node.js

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

package/dist/server/node_modules/kysely/dist/cjs/operation-node/binary-operation-node.d.ts

@@ -0,0 +1,16 @@
+import type { OperationNode } from './operation-node.js';
+export interface BinaryOperationNode extends OperationNode {
+    readonly kind: 'BinaryOperationNode';
+    readonly leftOperand: OperationNode;
+    readonly operator: OperationNode;
+    readonly rightOperand: OperationNode;
+}
+type BinaryOperationNodeFactory = Readonly<{
+    is(node: OperationNode): node is BinaryOperationNode;
+    create(leftOperand: OperationNode, operator: OperationNode, rightOperand: OperationNode): Readonly<BinaryOperationNode>;
+}>;
+/**
+ * @internal
+ */
+export declare const BinaryOperationNode: BinaryOperationNodeFactory;
+export {};

package/dist/server/node_modules/kysely/dist/cjs/operation-node/binary-operation-node.js

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

package/dist/server/node_modules/kysely/dist/cjs/operation-node/case-node.d.ts

@@ -0,0 +1,21 @@
+import type { OperationNode } from './operation-node.js';
+import { WhenNode } from './when-node.js';
+export interface CaseNode extends OperationNode {
+    readonly kind: 'CaseNode';
+    readonly value?: OperationNode;
+    readonly when?: ReadonlyArray<WhenNode>;
+    readonly else?: OperationNode;
+    readonly isStatement?: boolean;
+}
+type CaseNodeFactory = Readonly<{
+    is(node: OperationNode): node is CaseNode;
+    create(value?: OperationNode): Readonly<CaseNode>;
+    cloneWithWhen(caseNode: CaseNode, when: WhenNode): Readonly<CaseNode>;
+    cloneWithThen(caseNode: CaseNode, then: OperationNode): Readonly<CaseNode>;
+    cloneWith(caseNode: CaseNode, props: Partial<Pick<CaseNode, 'else' | 'isStatement'>>): Readonly<CaseNode>;
+}>;
+/**
+ * @internal
+ */
+export declare const CaseNode: CaseNodeFactory;
+export {};

package/dist/server/node_modules/kysely/dist/cjs/operation-node/case-node.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CaseNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+const when_node_js_1 = require("./when-node.js");
+/**
+ * @internal
+ */
+exports.CaseNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'CaseNode';
+    },
+    create(value) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'CaseNode',
+            value,
+        });
+    },
+    cloneWithWhen(caseNode, when) {
+        return (0, object_utils_js_1.freeze)({
+            ...caseNode,
+            when: (0, object_utils_js_1.freeze)(caseNode.when ? [...caseNode.when, when] : [when]),
+        });
+    },
+    cloneWithThen(caseNode, then) {
+        return (0, object_utils_js_1.freeze)({
+            ...caseNode,
+            when: caseNode.when
+                ? (0, object_utils_js_1.freeze)([
+                    ...caseNode.when.slice(0, -1),
+                    when_node_js_1.WhenNode.cloneWithResult(caseNode.when[caseNode.when.length - 1], then),
+                ])
+                : undefined,
+        });
+    },
+    cloneWith(caseNode, props) {
+        return (0, object_utils_js_1.freeze)({
+            ...caseNode,
+            ...props,
+        });
+    },
+});

package/dist/server/node_modules/kysely/dist/cjs/operation-node/cast-node.d.ts

@@ -0,0 +1,15 @@
+import type { OperationNode } from './operation-node.js';
+export interface CastNode extends OperationNode {
+    readonly kind: 'CastNode';
+    readonly expression: OperationNode;
+    readonly dataType: OperationNode;
+}
+type CastNodeFactory = Readonly<{
+    is(node: OperationNode): node is CastNode;
+    create(expression: OperationNode, dataType: OperationNode): Readonly<CastNode>;
+}>;
+/**
+ * @internal
+ */
+export declare const CastNode: CastNodeFactory;
+export {};

package/dist/server/node_modules/kysely/dist/cjs/operation-node/cast-node.js

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

package/dist/server/node_modules/kysely/dist/cjs/operation-node/check-constraint-node.d.ts

@@ -0,0 +1,16 @@
+import type { OperationNode } from './operation-node.js';
+import { IdentifierNode } from './identifier-node.js';
+export interface CheckConstraintNode extends OperationNode {
+    readonly kind: 'CheckConstraintNode';
+    readonly expression: OperationNode;
+    readonly name?: IdentifierNode;
+}
+type CheckConstraintNodeFactory = Readonly<{
+    is(node: OperationNode): node is CheckConstraintNode;
+    create(expression: OperationNode, constraintName?: string): Readonly<CheckConstraintNode>;
+}>;
+/**
+ * @internal
+ */
+export declare const CheckConstraintNode: CheckConstraintNodeFactory;
+export {};

package/dist/server/node_modules/kysely/dist/cjs/operation-node/check-constraint-node.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CheckConstraintNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+const identifier_node_js_1 = require("./identifier-node.js");
+/**
+ * @internal
+ */
+exports.CheckConstraintNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'CheckConstraintNode';
+    },
+    create(expression, constraintName) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'CheckConstraintNode',
+            expression,
+            name: constraintName
+                ? identifier_node_js_1.IdentifierNode.create(constraintName)
+                : undefined,
+        });
+    },
+});

package/dist/server/node_modules/kysely/dist/cjs/operation-node/collate-node.d.ts

@@ -0,0 +1,15 @@
+import { IdentifierNode } from './identifier-node.js';
+import type { OperationNode } from './operation-node.js';
+export interface CollateNode extends OperationNode {
+    readonly kind: 'CollateNode';
+    readonly collation: IdentifierNode;
+}
+type CollateNodeFactory = Readonly<{
+    is(node: OperationNode): node is CollateNode;
+    create(collation: string): Readonly<CollateNode>;
+}>;
+/**
+ * @internal
+ */
+export declare const CollateNode: CollateNodeFactory;
+export {};

package/dist/server/node_modules/kysely/dist/cjs/operation-node/collate-node.js

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

package/dist/server/node_modules/kysely/dist/cjs/operation-node/column-definition-node.d.ts

@@ -0,0 +1,38 @@
+import type { CheckConstraintNode } from './check-constraint-node.js';
+import { ColumnNode } from './column-node.js';
+import type { DefaultValueNode } from './default-value-node.js';
+import type { GeneratedNode } from './generated-node.js';
+import type { OperationNode } from './operation-node.js';
+import type { ReferencesNode } from './references-node.js';
+export type ColumnDefinitionNodeProps = Omit<Partial<ColumnDefinitionNode>, 'kind' | 'dataType'>;
+export interface ColumnDefinitionNode extends OperationNode {
+    readonly kind: 'ColumnDefinitionNode';
+    readonly column: ColumnNode;
+    readonly dataType: OperationNode;
+    readonly references?: ReferencesNode;
+    readonly primaryKey?: boolean;
+    readonly autoIncrement?: boolean;
+    readonly unique?: boolean;
+    readonly notNull?: boolean;
+    readonly defaultTo?: DefaultValueNode;
+    readonly check?: CheckConstraintNode;
+    readonly generated?: GeneratedNode;
+    readonly unsigned?: boolean;
+    readonly frontModifiers?: ReadonlyArray<OperationNode>;
+    readonly endModifiers?: ReadonlyArray<OperationNode>;
+    readonly nullsNotDistinct?: boolean;
+    readonly identity?: boolean;
+    readonly ifNotExists?: boolean;
+}
+type ColumnDefinitionNodeFactory = Readonly<{
+    is(node: OperationNode): node is ColumnDefinitionNode;
+    create(column: string, dataType: OperationNode): Readonly<ColumnDefinitionNode>;
+    cloneWithFrontModifier(node: ColumnDefinitionNode, modifier: OperationNode): Readonly<ColumnDefinitionNode>;
+    cloneWithEndModifier(node: ColumnDefinitionNode, modifier: OperationNode): Readonly<ColumnDefinitionNode>;
+    cloneWith(node: ColumnDefinitionNode, props: ColumnDefinitionNodeProps): Readonly<ColumnDefinitionNode>;
+}>;
+/**
+ * @internal
+ */
+export declare const ColumnDefinitionNode: ColumnDefinitionNodeFactory;
+export {};

package/dist/server/node_modules/kysely/dist/cjs/operation-node/column-definition-node.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ColumnDefinitionNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+const column_node_js_1 = require("./column-node.js");
+/**
+ * @internal
+ */
+exports.ColumnDefinitionNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'ColumnDefinitionNode';
+    },
+    create(column, dataType) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'ColumnDefinitionNode',
+            column: column_node_js_1.ColumnNode.create(column),
+            dataType,
+        });
+    },
+    cloneWithFrontModifier(node, modifier) {
+        return (0, object_utils_js_1.freeze)({
+            ...node,
+            frontModifiers: node.frontModifiers
+                ? (0, object_utils_js_1.freeze)([...node.frontModifiers, modifier])
+                : [modifier],
+        });
+    },
+    cloneWithEndModifier(node, modifier) {
+        return (0, object_utils_js_1.freeze)({
+            ...node,
+            endModifiers: node.endModifiers
+                ? (0, object_utils_js_1.freeze)([...node.endModifiers, modifier])
+                : [modifier],
+        });
+    },
+    cloneWith(node, props) {
+        return (0, object_utils_js_1.freeze)({
+            ...node,
+            ...props,
+        });
+    },
+});

package/dist/server/node_modules/kysely/dist/cjs/operation-node/column-node.d.ts

@@ -0,0 +1,15 @@
+import { IdentifierNode } from './identifier-node.js';
+import type { OperationNode } from './operation-node.js';
+export interface ColumnNode extends OperationNode {
+    readonly kind: 'ColumnNode';
+    readonly column: IdentifierNode;
+}
+type ColumnNodeFactory = Readonly<{
+    is(node: OperationNode): node is ColumnNode;
+    create(column: string): Readonly<ColumnNode>;
+}>;
+/**
+ * @internal
+ */
+export declare const ColumnNode: ColumnNodeFactory;
+export {};

package/dist/server/node_modules/kysely/dist/cjs/operation-node/column-node.js

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

package/dist/server/node_modules/kysely/dist/cjs/operation-node/column-update-node.d.ts

@@ -0,0 +1,15 @@
+import type { OperationNode } from './operation-node.js';
+export interface ColumnUpdateNode extends OperationNode {
+    readonly kind: 'ColumnUpdateNode';
+    readonly column: OperationNode;
+    readonly value: OperationNode;
+}
+type ColumnUpdateNodeFactory = Readonly<{
+    is(node: OperationNode): node is ColumnUpdateNode;
+    create(column: OperationNode, value: OperationNode): Readonly<ColumnUpdateNode>;
+}>;
+/**
+ * @internal
+ */
+export declare const ColumnUpdateNode: ColumnUpdateNodeFactory;
+export {};