@fragno-dev/workflows 0.0.1

package/dist/node/node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/cjs/schema/column-definition-builder.js

@@ -0,0 +1,595 @@
+import { __commonJS } from "../../../../../../../../_virtual/rolldown_runtime.js";
+import { require_select_all_node } from "../operation-node/select-all-node.js";
+import { require_reference_parser } from "../parser/reference-parser.js";
+import { require_column_definition_node } from "../operation-node/column-definition-node.js";
+import { require_check_constraint_node } from "../operation-node/check-constraint-node.js";
+import { require_references_node } from "../operation-node/references-node.js";
+import { require_default_value_parser } from "../parser/default-value-parser.js";
+import { require_generated_node } from "../operation-node/generated-node.js";
+import { require_default_value_node } from "../operation-node/default-value-node.js";
+import { require_on_modify_action_parser } from "../parser/on-modify-action-parser.js";
+
+//#region ../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/cjs/schema/column-definition-builder.js
+var require_column_definition_builder = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/cjs/schema/column-definition-builder.js": ((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.ColumnDefinitionBuilder = void 0;
+	const check_constraint_node_js_1 = require_check_constraint_node();
+	const references_node_js_1 = require_references_node();
+	const select_all_node_js_1 = require_select_all_node();
+	const reference_parser_js_1 = require_reference_parser();
+	const column_definition_node_js_1 = require_column_definition_node();
+	const default_value_parser_js_1 = require_default_value_parser();
+	const generated_node_js_1 = require_generated_node();
+	const default_value_node_js_1 = require_default_value_node();
+	const on_modify_action_parser_js_1 = require_on_modify_action_parser();
+	var ColumnDefinitionBuilder = class ColumnDefinitionBuilder {
+		#node;
+		constructor(node) {
+			this.#node = node;
+		}
+		/**
+		* Adds `auto_increment` or `autoincrement` to the column definition
+		* depending on the dialect.
+		*
+		* Some dialects like PostgreSQL don't support this. On PostgreSQL
+		* you can use the `serial` or `bigserial` data type instead.
+		*
+		* ### Examples
+		*
+		* ```ts
+		* await db.schema
+		*   .createTable('person')
+		*   .addColumn('id', 'integer', col => col.autoIncrement().primaryKey())
+		*   .execute()
+		* ```
+		*
+		* The generated SQL (MySQL):
+		*
+		* ```sql
+		* create table `person` (
+		*   `id` integer primary key auto_increment
+		* )
+		* ```
+		*/
+		autoIncrement() {
+			return new ColumnDefinitionBuilder(column_definition_node_js_1.ColumnDefinitionNode.cloneWith(this.#node, { autoIncrement: true }));
+		}
+		/**
+		* Makes the column an identity column.
+		*
+		* This only works on some dialects like MS SQL Server (MSSQL).
+		*
+		* For PostgreSQL's `generated always as identity` use {@link generatedAlwaysAsIdentity}.
+		*
+		* ### Examples
+		*
+		* ```ts
+		* await db.schema
+		*   .createTable('person')
+		*   .addColumn('id', 'integer', col => col.identity().primaryKey())
+		*   .execute()
+		* ```
+		*
+		* The generated SQL (MSSQL):
+		*
+		* ```sql
+		* create table "person" (
+		*   "id" integer identity primary key
+		* )
+		* ```
+		*/
+		identity() {
+			return new ColumnDefinitionBuilder(column_definition_node_js_1.ColumnDefinitionNode.cloneWith(this.#node, { identity: true }));
+		}
+		/**
+		* Makes the column the primary key.
+		*
+		* If you want to specify a composite primary key use the
+		* {@link CreateTableBuilder.addPrimaryKeyConstraint} method.
+		*
+		* ### Examples
+		*
+		* ```ts
+		* await db.schema
+		*   .createTable('person')
+		*   .addColumn('id', 'integer', col => col.primaryKey())
+		*   .execute()
+		* ```
+		*
+		* The generated SQL (MySQL):
+		*
+		* ```sql
+		* create table `person` (
+		*   `id` integer primary key
+		* )
+		*/
+		primaryKey() {
+			return new ColumnDefinitionBuilder(column_definition_node_js_1.ColumnDefinitionNode.cloneWith(this.#node, { primaryKey: true }));
+		}
+		/**
+		* Adds a foreign key constraint for the column.
+		*
+		* If your database engine doesn't support foreign key constraints in the
+		* column definition (like MySQL 5) you need to call the table level
+		* {@link CreateTableBuilder.addForeignKeyConstraint} method instead.
+		*
+		* ### Examples
+		*
+		* ```ts
+		* await db.schema
+		*   .createTable('pet')
+		*   .addColumn('owner_id', 'integer', (col) => col.references('person.id'))
+		*   .execute()
+		* ```
+		*
+		* The generated SQL (PostgreSQL):
+		*
+		* ```sql
+		* create table "pet" (
+		*   "owner_id" integer references "person" ("id")
+		* )
+		* ```
+		*/
+		references(ref) {
+			const references = (0, reference_parser_js_1.parseStringReference)(ref);
+			if (!references.table || select_all_node_js_1.SelectAllNode.is(references.column)) throw new Error(`invalid call references('${ref}'). The reference must have format table.column or schema.table.column`);
+			return new ColumnDefinitionBuilder(column_definition_node_js_1.ColumnDefinitionNode.cloneWith(this.#node, { references: references_node_js_1.ReferencesNode.create(references.table, [references.column]) }));
+		}
+		/**
+		* Adds an `on delete` constraint for the foreign key column.
+		*
+		* If your database engine doesn't support foreign key constraints in the
+		* column definition (like MySQL 5) you need to call the table level
+		* {@link CreateTableBuilder.addForeignKeyConstraint} method instead.
+		*
+		* ### Examples
+		*
+		* ```ts
+		* await db.schema
+		*   .createTable('pet')
+		*   .addColumn(
+		*     'owner_id',
+		*     'integer',
+		*     (col) => col.references('person.id').onDelete('cascade')
+		*   )
+		*   .execute()
+		* ```
+		*
+		* The generated SQL (PostgreSQL):
+		*
+		* ```sql
+		* create table "pet" (
+		*   "owner_id" integer references "person" ("id") on delete cascade
+		* )
+		* ```
+		*/
+		onDelete(onDelete) {
+			if (!this.#node.references) throw new Error("on delete constraint can only be added for foreign keys");
+			return new ColumnDefinitionBuilder(column_definition_node_js_1.ColumnDefinitionNode.cloneWith(this.#node, { references: references_node_js_1.ReferencesNode.cloneWithOnDelete(this.#node.references, (0, on_modify_action_parser_js_1.parseOnModifyForeignAction)(onDelete)) }));
+		}
+		/**
+		* Adds an `on update` constraint for the foreign key column.
+		*
+		* If your database engine doesn't support foreign key constraints in the
+		* column definition (like MySQL 5) you need to call the table level
+		* {@link CreateTableBuilder.addForeignKeyConstraint} method instead.
+		*
+		* ### Examples
+		*
+		* ```ts
+		* await db.schema
+		*   .createTable('pet')
+		*   .addColumn(
+		*     'owner_id',
+		*     'integer',
+		*     (col) => col.references('person.id').onUpdate('cascade')
+		*   )
+		*   .execute()
+		* ```
+		*
+		* The generated SQL (PostgreSQL):
+		*
+		* ```sql
+		* create table "pet" (
+		*   "owner_id" integer references "person" ("id") on update cascade
+		* )
+		* ```
+		*/
+		onUpdate(onUpdate) {
+			if (!this.#node.references) throw new Error("on update constraint can only be added for foreign keys");
+			return new ColumnDefinitionBuilder(column_definition_node_js_1.ColumnDefinitionNode.cloneWith(this.#node, { references: references_node_js_1.ReferencesNode.cloneWithOnUpdate(this.#node.references, (0, on_modify_action_parser_js_1.parseOnModifyForeignAction)(onUpdate)) }));
+		}
+		/**
+		* Adds a unique constraint for the column.
+		*
+		* ### Examples
+		*
+		* ```ts
+		* await db.schema
+		*   .createTable('person')
+		*   .addColumn('email', 'varchar(255)', col => col.unique())
+		*   .execute()
+		* ```
+		*
+		* The generated SQL (MySQL):
+		*
+		* ```sql
+		* create table `person` (
+		*   `email` varchar(255) unique
+		* )
+		* ```
+		*/
+		unique() {
+			return new ColumnDefinitionBuilder(column_definition_node_js_1.ColumnDefinitionNode.cloneWith(this.#node, { unique: true }));
+		}
+		/**
+		* Adds a `not null` constraint for the column.
+		*
+		* ### Examples
+		*
+		* ```ts
+		* await db.schema
+		*   .createTable('person')
+		*   .addColumn('first_name', 'varchar(255)', col => col.notNull())
+		*   .execute()
+		* ```
+		*
+		* The generated SQL (MySQL):
+		*
+		* ```sql
+		* create table `person` (
+		*   `first_name` varchar(255) not null
+		* )
+		* ```
+		*/
+		notNull() {
+			return new ColumnDefinitionBuilder(column_definition_node_js_1.ColumnDefinitionNode.cloneWith(this.#node, { notNull: true }));
+		}
+		/**
+		* Adds a `unsigned` modifier for the column.
+		*
+		* This only works on some dialects like MySQL.
+		*
+		* ### Examples
+		*
+		* ```ts
+		* await db.schema
+		*   .createTable('person')
+		*   .addColumn('age', 'integer', col => col.unsigned())
+		*   .execute()
+		* ```
+		*
+		* The generated SQL (MySQL):
+		*
+		* ```sql
+		* create table `person` (
+		*   `age` integer unsigned
+		* )
+		* ```
+		*/
+		unsigned() {
+			return new ColumnDefinitionBuilder(column_definition_node_js_1.ColumnDefinitionNode.cloneWith(this.#node, { unsigned: true }));
+		}
+		/**
+		* Adds a default value constraint for the column.
+		*
+		* ### Examples
+		*
+		* ```ts
+		* await db.schema
+		*   .createTable('pet')
+		*   .addColumn('number_of_legs', 'integer', (col) => col.defaultTo(4))
+		*   .execute()
+		* ```
+		*
+		* The generated SQL (MySQL):
+		*
+		* ```sql
+		* create table `pet` (
+		*   `number_of_legs` integer default 4
+		* )
+		* ```
+		*
+		* Values passed to `defaultTo` are interpreted as value literals by default. You can define
+		* an arbitrary SQL expression using the {@link sql} template tag:
+		*
+		* ```ts
+		* import { sql } from 'kysely'
+		*
+		* await db.schema
+		*   .createTable('pet')
+		*   .addColumn(
+		*     'created_at',
+		*     'timestamp',
+		*     (col) => col.defaultTo(sql`CURRENT_TIMESTAMP`)
+		*   )
+		*   .execute()
+		* ```
+		*
+		* The generated SQL (MySQL):
+		*
+		* ```sql
+		* create table `pet` (
+		*   `created_at` timestamp default CURRENT_TIMESTAMP
+		* )
+		* ```
+		*/
+		defaultTo(value) {
+			return new ColumnDefinitionBuilder(column_definition_node_js_1.ColumnDefinitionNode.cloneWith(this.#node, { defaultTo: default_value_node_js_1.DefaultValueNode.create((0, default_value_parser_js_1.parseDefaultValueExpression)(value)) }));
+		}
+		/**
+		* Adds a check constraint for the column.
+		*
+		* ### Examples
+		*
+		* ```ts
+		* import { sql } from 'kysely'
+		*
+		* await db.schema
+		*   .createTable('pet')
+		*   .addColumn('number_of_legs', 'integer', (col) =>
+		*     col.check(sql`number_of_legs < 5`)
+		*   )
+		*   .execute()
+		* ```
+		*
+		* The generated SQL (MySQL):
+		*
+		* ```sql
+		* create table `pet` (
+		*   `number_of_legs` integer check (number_of_legs < 5)
+		* )
+		* ```
+		*/
+		check(expression) {
+			return new ColumnDefinitionBuilder(column_definition_node_js_1.ColumnDefinitionNode.cloneWith(this.#node, { check: check_constraint_node_js_1.CheckConstraintNode.create(expression.toOperationNode()) }));
+		}
+		/**
+		* Makes the column a generated column using a `generated always as` statement.
+		*
+		* ### Examples
+		*
+		* ```ts
+		* import { sql } from 'kysely'
+		*
+		* await db.schema
+		*   .createTable('person')
+		*   .addColumn('full_name', 'varchar(255)',
+		*     (col) => col.generatedAlwaysAs(sql`concat(first_name, ' ', last_name)`)
+		*   )
+		*   .execute()
+		* ```
+		*
+		* The generated SQL (MySQL):
+		*
+		* ```sql
+		* create table `person` (
+		*   `full_name` varchar(255) generated always as (concat(first_name, ' ', last_name))
+		* )
+		* ```
+		*/
+		generatedAlwaysAs(expression) {
+			return new ColumnDefinitionBuilder(column_definition_node_js_1.ColumnDefinitionNode.cloneWith(this.#node, { generated: generated_node_js_1.GeneratedNode.createWithExpression(expression.toOperationNode()) }));
+		}
+		/**
+		* Adds the `generated always as identity` specifier.
+		*
+		* This only works on some dialects like PostgreSQL.
+		*
+		* For MS SQL Server (MSSQL)'s identity column use {@link identity}.
+		*
+		* ### Examples
+		*
+		* ```ts
+		* await db.schema
+		*   .createTable('person')
+		*   .addColumn('id', 'integer', col => col.generatedAlwaysAsIdentity().primaryKey())
+		*   .execute()
+		* ```
+		*
+		* The generated SQL (PostgreSQL):
+		*
+		* ```sql
+		* create table "person" (
+		*   "id" integer generated always as identity primary key
+		* )
+		* ```
+		*/
+		generatedAlwaysAsIdentity() {
+			return new ColumnDefinitionBuilder(column_definition_node_js_1.ColumnDefinitionNode.cloneWith(this.#node, { generated: generated_node_js_1.GeneratedNode.create({
+				identity: true,
+				always: true
+			}) }));
+		}
+		/**
+		* Adds the `generated by default as identity` specifier on supported dialects.
+		*
+		* This only works on some dialects like PostgreSQL.
+		*
+		* For MS SQL Server (MSSQL)'s identity column use {@link identity}.
+		*
+		* ### Examples
+		*
+		* ```ts
+		* await db.schema
+		*   .createTable('person')
+		*   .addColumn('id', 'integer', col => col.generatedByDefaultAsIdentity().primaryKey())
+		*   .execute()
+		* ```
+		*
+		* The generated SQL (PostgreSQL):
+		*
+		* ```sql
+		* create table "person" (
+		*   "id" integer generated by default as identity primary key
+		* )
+		* ```
+		*/
+		generatedByDefaultAsIdentity() {
+			return new ColumnDefinitionBuilder(column_definition_node_js_1.ColumnDefinitionNode.cloneWith(this.#node, { generated: generated_node_js_1.GeneratedNode.create({
+				identity: true,
+				byDefault: true
+			}) }));
+		}
+		/**
+		* Makes a generated column stored instead of virtual. This method can only
+		* be used with {@link generatedAlwaysAs}
+		*
+		* ### Examples
+		*
+		* ```ts
+		* import { sql } from 'kysely'
+		*
+		* await db.schema
+		*   .createTable('person')
+		*   .addColumn('full_name', 'varchar(255)', (col) => col
+		*     .generatedAlwaysAs(sql`concat(first_name, ' ', last_name)`)
+		*     .stored()
+		*   )
+		*   .execute()
+		* ```
+		*
+		* The generated SQL (MySQL):
+		*
+		* ```sql
+		* create table `person` (
+		*   `full_name` varchar(255) generated always as (concat(first_name, ' ', last_name)) stored
+		* )
+		* ```
+		*/
+		stored() {
+			if (!this.#node.generated) throw new Error("stored() can only be called after generatedAlwaysAs");
+			return new ColumnDefinitionBuilder(column_definition_node_js_1.ColumnDefinitionNode.cloneWith(this.#node, { generated: generated_node_js_1.GeneratedNode.cloneWith(this.#node.generated, { stored: true }) }));
+		}
+		/**
+		* This can be used to add any additional SQL right after the column's data type.
+		*
+		* ### Examples
+		*
+		* ```ts
+		* import { sql } from 'kysely'
+		*
+		* await db.schema
+		*   .createTable('person')
+		*   .addColumn('id', 'integer', col => col.primaryKey())
+		*   .addColumn(
+		*     'first_name',
+		*     'varchar(36)',
+		*     (col) => col.modifyFront(sql`collate utf8mb4_general_ci`).notNull()
+		*   )
+		*   .execute()
+		* ```
+		*
+		* The generated SQL (MySQL):
+		*
+		* ```sql
+		* create table `person` (
+		*   `id` integer primary key,
+		*   `first_name` varchar(36) collate utf8mb4_general_ci not null
+		* )
+		* ```
+		*/
+		modifyFront(modifier) {
+			return new ColumnDefinitionBuilder(column_definition_node_js_1.ColumnDefinitionNode.cloneWithFrontModifier(this.#node, modifier.toOperationNode()));
+		}
+		/**
+		* Adds `nulls not distinct` specifier.
+		* Should be used with `unique` constraint.
+		*
+		* This only works on some dialects like PostgreSQL.
+		*
+		* ### Examples
+		*
+		* ```ts
+		* db.schema
+		*   .createTable('person')
+		*   .addColumn('id', 'integer', col => col.primaryKey())
+		*   .addColumn('first_name', 'varchar(30)', col => col.unique().nullsNotDistinct())
+		*   .execute()
+		* ```
+		*
+		* The generated SQL (PostgreSQL):
+		*
+		* ```sql
+		* create table "person" (
+		*   "id" integer primary key,
+		*   "first_name" varchar(30) unique nulls not distinct
+		* )
+		* ```
+		*/
+		nullsNotDistinct() {
+			return new ColumnDefinitionBuilder(column_definition_node_js_1.ColumnDefinitionNode.cloneWith(this.#node, { nullsNotDistinct: true }));
+		}
+		/**
+		* Adds `if not exists` specifier. This only works for PostgreSQL.
+		*
+		* ### Examples
+		*
+		* ```ts
+		* await db.schema
+		*   .alterTable('person')
+		*   .addColumn('email', 'varchar(255)', col => col.unique().ifNotExists())
+		*   .execute()
+		* ```
+		*
+		* The generated SQL (PostgreSQL):
+		*
+		* ```sql
+		* alter table "person" add column if not exists "email" varchar(255) unique
+		* ```
+		*/
+		ifNotExists() {
+			return new ColumnDefinitionBuilder(column_definition_node_js_1.ColumnDefinitionNode.cloneWith(this.#node, { ifNotExists: true }));
+		}
+		/**
+		* This can be used to add any additional SQL to the end of the column definition.
+		*
+		* ### Examples
+		*
+		* ```ts
+		* import { sql } from 'kysely'
+		*
+		* await db.schema
+		*   .createTable('person')
+		*   .addColumn('id', 'integer', col => col.primaryKey())
+		*   .addColumn(
+		*     'age',
+		*     'integer',
+		*     col => col.unsigned()
+		*       .notNull()
+		*       .modifyEnd(sql`comment ${sql.lit('it is not polite to ask a woman her age')}`)
+		*   )
+		*   .execute()
+		* ```
+		*
+		* The generated SQL (MySQL):
+		*
+		* ```sql
+		* create table `person` (
+		*   `id` integer primary key,
+		*   `age` integer unsigned not null comment 'it is not polite to ask a woman her age'
+		* )
+		* ```
+		*/
+		modifyEnd(modifier) {
+			return new ColumnDefinitionBuilder(column_definition_node_js_1.ColumnDefinitionNode.cloneWithEndModifier(this.#node, modifier.toOperationNode()));
+		}
+		/**
+		* Simply calls the provided function passing `this` as the only argument. `$call` returns
+		* what the provided function returns.
+		*/
+		$call(func) {
+			return func(this);
+		}
+		toOperationNode() {
+			return this.#node;
+		}
+	};
+	exports.ColumnDefinitionBuilder = ColumnDefinitionBuilder;
+}) });
+
+//#endregion
+export default require_column_definition_builder();
+
+export { require_column_definition_builder };
+//# sourceMappingURL=column-definition-builder.js.map

package/dist/node/node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/cjs/schema/column-definition-builder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"column-definition-builder.js","names":["#node"],"sources":["../../../../../../../../../../../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/cjs/schema/column-definition-builder.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.ColumnDefinitionBuilder = void 0;\nconst check_constraint_node_js_1 = require(\"../operation-node/check-constraint-node.js\");\nconst references_node_js_1 = require(\"../operation-node/references-node.js\");\nconst select_all_node_js_1 = require(\"../operation-node/select-all-node.js\");\nconst reference_parser_js_1 = require(\"../parser/reference-parser.js\");\nconst column_definition_node_js_1 = require(\"../operation-node/column-definition-node.js\");\nconst default_value_parser_js_1 = require(\"../parser/default-value-parser.js\");\nconst generated_node_js_1 = require(\"../operation-node/generated-node.js\");\nconst default_value_node_js_1 = require(\"../operation-node/default-value-node.js\");\nconst on_modify_action_parser_js_1 = require(\"../parser/on-modify-action-parser.js\");\nclass ColumnDefinitionBuilder {\n    #node;\n    constructor(node) {\n        this.#node = node;\n    }\n    /**\n     * Adds `auto_increment` or `autoincrement` to the column definition\n     * depending on the dialect.\n     *\n     * Some dialects like PostgreSQL don't support this. On PostgreSQL\n     * you can use the `serial` or `bigserial` data type instead.\n     *\n     * ### Examples\n     *\n     * ```ts\n     * await db.schema\n     *   .createTable('person')\n     *   .addColumn('id', 'integer', col => col.autoIncrement().primaryKey())\n     *   .execute()\n     * ```\n     *\n     * The generated SQL (MySQL):\n     *\n     * ```sql\n     * create table `person` (\n     *   `id` integer primary key auto_increment\n     * )\n     * ```\n     */\n    autoIncrement() {\n        return new ColumnDefinitionBuilder(column_definition_node_js_1.ColumnDefinitionNode.cloneWith(this.#node, { autoIncrement: true }));\n    }\n    /**\n     * Makes the column an identity column.\n     *\n     * This only works on some dialects like MS SQL Server (MSSQL).\n     *\n     * For PostgreSQL's `generated always as identity` use {@link generatedAlwaysAsIdentity}.\n     *\n     * ### Examples\n     *\n     * ```ts\n     * await db.schema\n     *   .createTable('person')\n     *   .addColumn('id', 'integer', col => col.identity().primaryKey())\n     *   .execute()\n     * ```\n     *\n     * The generated SQL (MSSQL):\n     *\n     * ```sql\n     * create table \"person\" (\n     *   \"id\" integer identity primary key\n     * )\n     * ```\n     */\n    identity() {\n        return new ColumnDefinitionBuilder(column_definition_node_js_1.ColumnDefinitionNode.cloneWith(this.#node, { identity: true }));\n    }\n    /**\n     * Makes the column the primary key.\n     *\n     * If you want to specify a composite primary key use the\n     * {@link CreateTableBuilder.addPrimaryKeyConstraint} method.\n     *\n     * ### Examples\n     *\n     * ```ts\n     * await db.schema\n     *   .createTable('person')\n     *   .addColumn('id', 'integer', col => col.primaryKey())\n     *   .execute()\n     * ```\n     *\n     * The generated SQL (MySQL):\n     *\n     * ```sql\n     * create table `person` (\n     *   `id` integer primary key\n     * )\n     */\n    primaryKey() {\n        return new ColumnDefinitionBuilder(column_definition_node_js_1.ColumnDefinitionNode.cloneWith(this.#node, { primaryKey: true }));\n    }\n    /**\n     * Adds a foreign key constraint for the column.\n     *\n     * If your database engine doesn't support foreign key constraints in the\n     * column definition (like MySQL 5) you need to call the table level\n     * {@link CreateTableBuilder.addForeignKeyConstraint} method instead.\n     *\n     * ### Examples\n     *\n     * ```ts\n     * await db.schema\n     *   .createTable('pet')\n     *   .addColumn('owner_id', 'integer', (col) => col.references('person.id'))\n     *   .execute()\n     * ```\n     *\n     * The generated SQL (PostgreSQL):\n     *\n     * ```sql\n     * create table \"pet\" (\n     *   \"owner_id\" integer references \"person\" (\"id\")\n     * )\n     * ```\n     */\n    references(ref) {\n        const references = (0, reference_parser_js_1.parseStringReference)(ref);\n        if (!references.table || select_all_node_js_1.SelectAllNode.is(references.column)) {\n            throw new Error(`invalid call references('${ref}'). The reference must have format table.column or schema.table.column`);\n        }\n        return new ColumnDefinitionBuilder(column_definition_node_js_1.ColumnDefinitionNode.cloneWith(this.#node, {\n            references: references_node_js_1.ReferencesNode.create(references.table, [\n                references.column,\n            ]),\n        }));\n    }\n    /**\n     * Adds an `on delete` constraint for the foreign key column.\n     *\n     * If your database engine doesn't support foreign key constraints in the\n     * column definition (like MySQL 5) you need to call the table level\n     * {@link CreateTableBuilder.addForeignKeyConstraint} method instead.\n     *\n     * ### Examples\n     *\n     * ```ts\n     * await db.schema\n     *   .createTable('pet')\n     *   .addColumn(\n     *     'owner_id',\n     *     'integer',\n     *     (col) => col.references('person.id').onDelete('cascade')\n     *   )\n     *   .execute()\n     * ```\n     *\n     * The generated SQL (PostgreSQL):\n     *\n     * ```sql\n     * create table \"pet\" (\n     *   \"owner_id\" integer references \"person\" (\"id\") on delete cascade\n     * )\n     * ```\n     */\n    onDelete(onDelete) {\n        if (!this.#node.references) {\n            throw new Error('on delete constraint can only be added for foreign keys');\n        }\n        return new ColumnDefinitionBuilder(column_definition_node_js_1.ColumnDefinitionNode.cloneWith(this.#node, {\n            references: references_node_js_1.ReferencesNode.cloneWithOnDelete(this.#node.references, (0, on_modify_action_parser_js_1.parseOnModifyForeignAction)(onDelete)),\n        }));\n    }\n    /**\n     * Adds an `on update` constraint for the foreign key column.\n     *\n     * If your database engine doesn't support foreign key constraints in the\n     * column definition (like MySQL 5) you need to call the table level\n     * {@link CreateTableBuilder.addForeignKeyConstraint} method instead.\n     *\n     * ### Examples\n     *\n     * ```ts\n     * await db.schema\n     *   .createTable('pet')\n     *   .addColumn(\n     *     'owner_id',\n     *     'integer',\n     *     (col) => col.references('person.id').onUpdate('cascade')\n     *   )\n     *   .execute()\n     * ```\n     *\n     * The generated SQL (PostgreSQL):\n     *\n     * ```sql\n     * create table \"pet\" (\n     *   \"owner_id\" integer references \"person\" (\"id\") on update cascade\n     * )\n     * ```\n     */\n    onUpdate(onUpdate) {\n        if (!this.#node.references) {\n            throw new Error('on update constraint can only be added for foreign keys');\n        }\n        return new ColumnDefinitionBuilder(column_definition_node_js_1.ColumnDefinitionNode.cloneWith(this.#node, {\n            references: references_node_js_1.ReferencesNode.cloneWithOnUpdate(this.#node.references, (0, on_modify_action_parser_js_1.parseOnModifyForeignAction)(onUpdate)),\n        }));\n    }\n    /**\n     * Adds a unique constraint for the column.\n     *\n     * ### Examples\n     *\n     * ```ts\n     * await db.schema\n     *   .createTable('person')\n     *   .addColumn('email', 'varchar(255)', col => col.unique())\n     *   .execute()\n     * ```\n     *\n     * The generated SQL (MySQL):\n     *\n     * ```sql\n     * create table `person` (\n     *   `email` varchar(255) unique\n     * )\n     * ```\n     */\n    unique() {\n        return new ColumnDefinitionBuilder(column_definition_node_js_1.ColumnDefinitionNode.cloneWith(this.#node, { unique: true }));\n    }\n    /**\n     * Adds a `not null` constraint for the column.\n     *\n     * ### Examples\n     *\n     * ```ts\n     * await db.schema\n     *   .createTable('person')\n     *   .addColumn('first_name', 'varchar(255)', col => col.notNull())\n     *   .execute()\n     * ```\n     *\n     * The generated SQL (MySQL):\n     *\n     * ```sql\n     * create table `person` (\n     *   `first_name` varchar(255) not null\n     * )\n     * ```\n     */\n    notNull() {\n        return new ColumnDefinitionBuilder(column_definition_node_js_1.ColumnDefinitionNode.cloneWith(this.#node, { notNull: true }));\n    }\n    /**\n     * Adds a `unsigned` modifier for the column.\n     *\n     * This only works on some dialects like MySQL.\n     *\n     * ### Examples\n     *\n     * ```ts\n     * await db.schema\n     *   .createTable('person')\n     *   .addColumn('age', 'integer', col => col.unsigned())\n     *   .execute()\n     * ```\n     *\n     * The generated SQL (MySQL):\n     *\n     * ```sql\n     * create table `person` (\n     *   `age` integer unsigned\n     * )\n     * ```\n     */\n    unsigned() {\n        return new ColumnDefinitionBuilder(column_definition_node_js_1.ColumnDefinitionNode.cloneWith(this.#node, { unsigned: true }));\n    }\n    /**\n     * Adds a default value constraint for the column.\n     *\n     * ### Examples\n     *\n     * ```ts\n     * await db.schema\n     *   .createTable('pet')\n     *   .addColumn('number_of_legs', 'integer', (col) => col.defaultTo(4))\n     *   .execute()\n     * ```\n     *\n     * The generated SQL (MySQL):\n     *\n     * ```sql\n     * create table `pet` (\n     *   `number_of_legs` integer default 4\n     * )\n     * ```\n     *\n     * Values passed to `defaultTo` are interpreted as value literals by default. You can define\n     * an arbitrary SQL expression using the {@link sql} template tag:\n     *\n     * ```ts\n     * import { sql } from 'kysely'\n     *\n     * await db.schema\n     *   .createTable('pet')\n     *   .addColumn(\n     *     'created_at',\n     *     'timestamp',\n     *     (col) => col.defaultTo(sql`CURRENT_TIMESTAMP`)\n     *   )\n     *   .execute()\n     * ```\n     *\n     * The generated SQL (MySQL):\n     *\n     * ```sql\n     * create table `pet` (\n     *   `created_at` timestamp default CURRENT_TIMESTAMP\n     * )\n     * ```\n     */\n    defaultTo(value) {\n        return new ColumnDefinitionBuilder(column_definition_node_js_1.ColumnDefinitionNode.cloneWith(this.#node, {\n            defaultTo: default_value_node_js_1.DefaultValueNode.create((0, default_value_parser_js_1.parseDefaultValueExpression)(value)),\n        }));\n    }\n    /**\n     * Adds a check constraint for the column.\n     *\n     * ### Examples\n     *\n     * ```ts\n     * import { sql } from 'kysely'\n     *\n     * await db.schema\n     *   .createTable('pet')\n     *   .addColumn('number_of_legs', 'integer', (col) =>\n     *     col.check(sql`number_of_legs < 5`)\n     *   )\n     *   .execute()\n     * ```\n     *\n     * The generated SQL (MySQL):\n     *\n     * ```sql\n     * create table `pet` (\n     *   `number_of_legs` integer check (number_of_legs < 5)\n     * )\n     * ```\n     */\n    check(expression) {\n        return new ColumnDefinitionBuilder(column_definition_node_js_1.ColumnDefinitionNode.cloneWith(this.#node, {\n            check: check_constraint_node_js_1.CheckConstraintNode.create(expression.toOperationNode()),\n        }));\n    }\n    /**\n     * Makes the column a generated column using a `generated always as` statement.\n     *\n     * ### Examples\n     *\n     * ```ts\n     * import { sql } from 'kysely'\n     *\n     * await db.schema\n     *   .createTable('person')\n     *   .addColumn('full_name', 'varchar(255)',\n     *     (col) => col.generatedAlwaysAs(sql`concat(first_name, ' ', last_name)`)\n     *   )\n     *   .execute()\n     * ```\n     *\n     * The generated SQL (MySQL):\n     *\n     * ```sql\n     * create table `person` (\n     *   `full_name` varchar(255) generated always as (concat(first_name, ' ', last_name))\n     * )\n     * ```\n     */\n    generatedAlwaysAs(expression) {\n        return new ColumnDefinitionBuilder(column_definition_node_js_1.ColumnDefinitionNode.cloneWith(this.#node, {\n            generated: generated_node_js_1.GeneratedNode.createWithExpression(expression.toOperationNode()),\n        }));\n    }\n    /**\n     * Adds the `generated always as identity` specifier.\n     *\n     * This only works on some dialects like PostgreSQL.\n     *\n     * For MS SQL Server (MSSQL)'s identity column use {@link identity}.\n     *\n     * ### Examples\n     *\n     * ```ts\n     * await db.schema\n     *   .createTable('person')\n     *   .addColumn('id', 'integer', col => col.generatedAlwaysAsIdentity().primaryKey())\n     *   .execute()\n     * ```\n     *\n     * The generated SQL (PostgreSQL):\n     *\n     * ```sql\n     * create table \"person\" (\n     *   \"id\" integer generated always as identity primary key\n     * )\n     * ```\n     */\n    generatedAlwaysAsIdentity() {\n        return new ColumnDefinitionBuilder(column_definition_node_js_1.ColumnDefinitionNode.cloneWith(this.#node, {\n            generated: generated_node_js_1.GeneratedNode.create({ identity: true, always: true }),\n        }));\n    }\n    /**\n     * Adds the `generated by default as identity` specifier on supported dialects.\n     *\n     * This only works on some dialects like PostgreSQL.\n     *\n     * For MS SQL Server (MSSQL)'s identity column use {@link identity}.\n     *\n     * ### Examples\n     *\n     * ```ts\n     * await db.schema\n     *   .createTable('person')\n     *   .addColumn('id', 'integer', col => col.generatedByDefaultAsIdentity().primaryKey())\n     *   .execute()\n     * ```\n     *\n     * The generated SQL (PostgreSQL):\n     *\n     * ```sql\n     * create table \"person\" (\n     *   \"id\" integer generated by default as identity primary key\n     * )\n     * ```\n     */\n    generatedByDefaultAsIdentity() {\n        return new ColumnDefinitionBuilder(column_definition_node_js_1.ColumnDefinitionNode.cloneWith(this.#node, {\n            generated: generated_node_js_1.GeneratedNode.create({ identity: true, byDefault: true }),\n        }));\n    }\n    /**\n     * Makes a generated column stored instead of virtual. This method can only\n     * be used with {@link generatedAlwaysAs}\n     *\n     * ### Examples\n     *\n     * ```ts\n     * import { sql } from 'kysely'\n     *\n     * await db.schema\n     *   .createTable('person')\n     *   .addColumn('full_name', 'varchar(255)', (col) => col\n     *     .generatedAlwaysAs(sql`concat(first_name, ' ', last_name)`)\n     *     .stored()\n     *   )\n     *   .execute()\n     * ```\n     *\n     * The generated SQL (MySQL):\n     *\n     * ```sql\n     * create table `person` (\n     *   `full_name` varchar(255) generated always as (concat(first_name, ' ', last_name)) stored\n     * )\n     * ```\n     */\n    stored() {\n        if (!this.#node.generated) {\n            throw new Error('stored() can only be called after generatedAlwaysAs');\n        }\n        return new ColumnDefinitionBuilder(column_definition_node_js_1.ColumnDefinitionNode.cloneWith(this.#node, {\n            generated: generated_node_js_1.GeneratedNode.cloneWith(this.#node.generated, {\n                stored: true,\n            }),\n        }));\n    }\n    /**\n     * This can be used to add any additional SQL right after the column's data type.\n     *\n     * ### Examples\n     *\n     * ```ts\n     * import { sql } from 'kysely'\n     *\n     * await db.schema\n     *   .createTable('person')\n     *   .addColumn('id', 'integer', col => col.primaryKey())\n     *   .addColumn(\n     *     'first_name',\n     *     'varchar(36)',\n     *     (col) => col.modifyFront(sql`collate utf8mb4_general_ci`).notNull()\n     *   )\n     *   .execute()\n     * ```\n     *\n     * The generated SQL (MySQL):\n     *\n     * ```sql\n     * create table `person` (\n     *   `id` integer primary key,\n     *   `first_name` varchar(36) collate utf8mb4_general_ci not null\n     * )\n     * ```\n     */\n    modifyFront(modifier) {\n        return new ColumnDefinitionBuilder(column_definition_node_js_1.ColumnDefinitionNode.cloneWithFrontModifier(this.#node, modifier.toOperationNode()));\n    }\n    /**\n     * Adds `nulls not distinct` specifier.\n     * Should be used with `unique` constraint.\n     *\n     * This only works on some dialects like PostgreSQL.\n     *\n     * ### Examples\n     *\n     * ```ts\n     * db.schema\n     *   .createTable('person')\n     *   .addColumn('id', 'integer', col => col.primaryKey())\n     *   .addColumn('first_name', 'varchar(30)', col => col.unique().nullsNotDistinct())\n     *   .execute()\n     * ```\n     *\n     * The generated SQL (PostgreSQL):\n     *\n     * ```sql\n     * create table \"person\" (\n     *   \"id\" integer primary key,\n     *   \"first_name\" varchar(30) unique nulls not distinct\n     * )\n     * ```\n     */\n    nullsNotDistinct() {\n        return new ColumnDefinitionBuilder(column_definition_node_js_1.ColumnDefinitionNode.cloneWith(this.#node, { nullsNotDistinct: true }));\n    }\n    /**\n     * Adds `if not exists` specifier. This only works for PostgreSQL.\n     *\n     * ### Examples\n     *\n     * ```ts\n     * await db.schema\n     *   .alterTable('person')\n     *   .addColumn('email', 'varchar(255)', col => col.unique().ifNotExists())\n     *   .execute()\n     * ```\n     *\n     * The generated SQL (PostgreSQL):\n     *\n     * ```sql\n     * alter table \"person\" add column if not exists \"email\" varchar(255) unique\n     * ```\n     */\n    ifNotExists() {\n        return new ColumnDefinitionBuilder(column_definition_node_js_1.ColumnDefinitionNode.cloneWith(this.#node, { ifNotExists: true }));\n    }\n    /**\n     * This can be used to add any additional SQL to the end of the column definition.\n     *\n     * ### Examples\n     *\n     * ```ts\n     * import { sql } from 'kysely'\n     *\n     * await db.schema\n     *   .createTable('person')\n     *   .addColumn('id', 'integer', col => col.primaryKey())\n     *   .addColumn(\n     *     'age',\n     *     'integer',\n     *     col => col.unsigned()\n     *       .notNull()\n     *       .modifyEnd(sql`comment ${sql.lit('it is not polite to ask a woman her age')}`)\n     *   )\n     *   .execute()\n     * ```\n     *\n     * The generated SQL (MySQL):\n     *\n     * ```sql\n     * create table `person` (\n     *   `id` integer primary key,\n     *   `age` integer unsigned not null comment 'it is not polite to ask a woman her age'\n     * )\n     * ```\n     */\n    modifyEnd(modifier) {\n        return new ColumnDefinitionBuilder(column_definition_node_js_1.ColumnDefinitionNode.cloneWithEndModifier(this.#node, modifier.toOperationNode()));\n    }\n    /**\n     * Simply calls the provided function passing `this` as the only argument. `$call` returns\n     * what the provided function returns.\n     */\n    $call(func) {\n        return func(this);\n    }\n    toOperationNode() {\n        return this.#node;\n    }\n}\nexports.ColumnDefinitionBuilder = ColumnDefinitionBuilder;\n"],"x_google_ignoreList":[0],"mappings":"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"}