kysely 0.28.17 → 0.29.0

package/dist/schema/alter-table-add-index-builder.js

@@ -0,0 +1,151 @@
+/// <reference types="./alter-table-add-index-builder.d.ts" />
+import { AddIndexNode } from '../operation-node/add-index-node.js';
+import { AlterTableNode } from '../operation-node/alter-table-node.js';
+import { RawNode } from '../operation-node/raw-node.js';
+import { parseOrderedColumnName, } from '../parser/reference-parser.js';
+import { freeze, isString } from '../util/object-utils.js';
+export class AlterTableAddIndexBuilder {
+    #props;
+    constructor(props) {
+        this.#props = freeze(props);
+    }
+    /**
+     * Makes the index unique.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * await db.schema
+     *   .alterTable('person')
+     *   .addIndex('person_first_name_index')
+     *   .unique()
+     *   .column('email')
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (MySQL):
+     *
+     * ```sql
+     * alter table `person` add unique index `person_first_name_index` (`email`)
+     * ```
+     */
+    unique() {
+        return new AlterTableAddIndexBuilder({
+            ...this.#props,
+            node: AlterTableNode.cloneWithTableProps(this.#props.node, {
+                addIndex: AddIndexNode.cloneWith(this.#props.node.addIndex, {
+                    unique: true,
+                }),
+            }),
+        });
+    }
+    column(arg) {
+        return new AlterTableAddIndexBuilder({
+            ...this.#props,
+            node: AlterTableNode.cloneWithTableProps(this.#props.node, {
+                addIndex: AddIndexNode.cloneWithColumns(this.#props.node.addIndex, [
+                    isString(arg) ? parseOrderedColumnName(arg) : arg.toOperationNode(),
+                ]),
+            }),
+        });
+    }
+    /**
+     * Specifies a list of columns for the index.
+     *
+     * Also see {@link column} for adding a single column or {@link expression} for
+     * specifying an arbitrary expression.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * import { sql } from 'kysely'
+     *
+     * await db.schema
+     *   .alterTable('person')
+     *   .addIndex('person_first_name_and_age_index')
+     *   .columns(['first_name', sql`(left(lower(last_name), 1))`, 'age desc'])
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (MySQL):
+     *
+     * ```sql
+     * alter table `person`
+     * add index `person_first_name_and_age_index` (
+     *   `first_name`,
+     *   (left(lower(last_name), 1)),
+     *   `age` desc
+     * )
+     * ```
+     */
+    columns(columns) {
+        return new AlterTableAddIndexBuilder({
+            ...this.#props,
+            node: AlterTableNode.cloneWithTableProps(this.#props.node, {
+                addIndex: AddIndexNode.cloneWithColumns(this.#props.node.addIndex, columns.map((item) => isString(item)
+                    ? parseOrderedColumnName(item)
+                    : item.toOperationNode())),
+            }),
+        });
+    }
+    /**
+     * Specifies an arbitrary expression for the index.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * import { sql } from 'kysely'
+     *
+     * await db.schema
+     *   .alterTable('person')
+     *   .addIndex('person_first_name_index')
+     *   .expression(sql<boolean>`(first_name < 'Sami')`)
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (MySQL):
+     *
+     * ```sql
+     * alter table `person` add index `person_first_name_index` ((first_name < 'Sami'))
+     * ```
+     *
+     * @deprecated Use {@link column} or {@link columns} with an {@link Expression} instead.
+     */
+    // TODO: remove in v0.30
+    expression(expression) {
+        return new AlterTableAddIndexBuilder({
+            ...this.#props,
+            node: AlterTableNode.cloneWithTableProps(this.#props.node, {
+                addIndex: AddIndexNode.cloneWithColumns(this.#props.node.addIndex, [
+                    expression.toOperationNode(),
+                ]),
+            }),
+        });
+    }
+    using(indexType) {
+        return new AlterTableAddIndexBuilder({
+            ...this.#props,
+            node: AlterTableNode.cloneWithTableProps(this.#props.node, {
+                addIndex: AddIndexNode.cloneWith(this.#props.node.addIndex, {
+                    using: RawNode.createWithSql(indexType),
+                }),
+            }),
+        });
+    }
+    /**
+     * 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.#props.executor.transformQuery(this.#props.node, this.#props.queryId);
+    }
+    compile() {
+        return this.#props.executor.compileQuery(this.toOperationNode(), this.#props.queryId);
+    }
+    async execute(options) {
+        await this.#props.executor.executeQuery(this.compile(), options);
+    }
+}

package/dist/schema/alter-table-builder.d.ts

@@ -0,0 +1,151 @@
+import { AlterTableNode } from '../operation-node/alter-table-node.js';
+import type { OperationNodeSource } from '../operation-node/operation-node-source.js';
+import type { CompiledQuery } from '../query-compiler/compiled-query.js';
+import type { Compilable } from '../util/compilable.js';
+import { type ColumnDefinitionBuilderCallback } from './column-definition-builder.js';
+import type { QueryId } from '../util/query-id.js';
+import type { QueryExecutor } from '../query-executor/query-executor.js';
+import { type DataTypeExpression } from '../parser/data-type-parser.js';
+import { type ForeignKeyConstraintBuilderCallback } from './foreign-key-constraint-builder.js';
+import type { Expression } from '../expression/expression.js';
+import { type AlterColumnBuilderCallback } from './alter-column-builder.js';
+import { AlterTableExecutor } from './alter-table-executor.js';
+import { AlterTableAddForeignKeyConstraintBuilder } from './alter-table-add-foreign-key-constraint-builder.js';
+import { AlterTableDropConstraintBuilder } from './alter-table-drop-constraint-builder.js';
+import { AlterTableAddIndexBuilder } from './alter-table-add-index-builder.js';
+import { type UniqueConstraintNodeBuilderCallback } from './unique-constraint-builder.js';
+import { type PrimaryKeyConstraintBuilderCallback } from './primary-key-constraint-builder.js';
+import { type CheckConstraintBuilderCallback } from './check-constraint-builder.js';
+import { type ExpressionOrFactory } from '../parser/expression-parser.js';
+import { type DropColumnBuilderCallback } from './drop-column-builder.js';
+import type { AbortableQueryOptions } from '../util/abort.js';
+/**
+ * This builder can be used to create a `alter table` query.
+ */
+export declare class AlterTableBuilder implements ColumnAlteringInterface {
+    #private;
+    constructor(props: AlterTableBuilderProps);
+    renameTo(newTableName: string): AlterTableExecutor;
+    setSchema(newSchema: string): AlterTableExecutor;
+    alterColumn(column: string, alteration: AlterColumnBuilderCallback): AlterTableColumnAlteringBuilder;
+    dropColumn(column: string, build?: DropColumnBuilderCallback): AlterTableColumnAlteringBuilder;
+    renameColumn(column: string, newColumn: string): AlterTableColumnAlteringBuilder;
+    /**
+     * See {@link CreateTableBuilder.addColumn}
+     */
+    addColumn(columnName: string, dataType: DataTypeExpression, build?: ColumnDefinitionBuilderCallback): AlterTableColumnAlteringBuilder;
+    /**
+     * Creates an `alter table modify column` query. The `modify column` statement
+     * is only implemeted by MySQL and oracle AFAIK. On other databases you
+     * should use the `alterColumn` method.
+     */
+    modifyColumn(columnName: string, dataType: DataTypeExpression, build?: ColumnDefinitionBuilderCallback): AlterTableColumnAlteringBuilder;
+    /**
+     * See {@link CreateTableBuilder.addUniqueConstraint}
+     */
+    addUniqueConstraint(constraintName: string, columns: (string | ExpressionOrFactory<any, any, any>)[], build?: UniqueConstraintNodeBuilderCallback): AlterTableExecutor;
+    /**
+     * See {@link CreateTableBuilder.addCheckConstraint}
+     */
+    addCheckConstraint(constraintName: string, checkExpression: Expression<any>, build?: CheckConstraintBuilderCallback): AlterTableExecutor;
+    /**
+     * See {@link CreateTableBuilder.addForeignKeyConstraint}
+     *
+     * Unlike {@link CreateTableBuilder.addForeignKeyConstraint} this method returns
+     * the constraint builder and doesn't take a callback as the last argument. This
+     * is because you can only add one column per `ALTER TABLE` query.
+     */
+    addForeignKeyConstraint(constraintName: string, columns: string[], targetTable: string, targetColumns: string[], build?: ForeignKeyConstraintBuilderCallback): AlterTableAddForeignKeyConstraintBuilder;
+    /**
+     * See {@link CreateTableBuilder.addPrimaryKeyConstraint}
+     */
+    addPrimaryKeyConstraint(constraintName: string, columns: string[], build?: PrimaryKeyConstraintBuilderCallback): AlterTableExecutor;
+    dropConstraint(constraintName: string): AlterTableDropConstraintBuilder;
+    renameConstraint(oldName: string, newName: string): AlterTableDropConstraintBuilder;
+    /**
+     * This can be used to add index to table.
+     *
+     *  ### Examples
+     *
+     * ```ts
+     * db.schema.alterTable('person')
+     *   .addIndex('person_email_index')
+     *   .column('email')
+     *   .unique()
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (MySQL):
+     *
+     * ```sql
+     * alter table `person` add unique index `person_email_index` (`email`)
+     * ```
+     */
+    addIndex(indexName: string): AlterTableAddIndexBuilder;
+    /**
+     * This can be used to drop index from table.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.schema.alterTable('person')
+     *   .dropIndex('person_email_index')
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (MySQL):
+     *
+     * ```sql
+     * alter table `person` drop index `test_first_name_index`
+     * ```
+     */
+    dropIndex(indexName: string): AlterTableExecutor;
+    /**
+     * Calls the given function passing `this` as the only argument.
+     *
+     * See {@link CreateTableBuilder.$call}
+     */
+    $call<T>(func: (qb: this) => T): T;
+}
+export interface AlterTableBuilderProps {
+    readonly executor: QueryExecutor;
+    readonly node: AlterTableNode;
+    readonly queryId: QueryId;
+}
+export interface ColumnAlteringInterface {
+    alterColumn(column: string, alteration: AlterColumnBuilderCallback): ColumnAlteringInterface;
+    dropColumn(column: string): ColumnAlteringInterface;
+    renameColumn(column: string, newColumn: string): ColumnAlteringInterface;
+    /**
+     * See {@link CreateTableBuilder.addColumn}
+     */
+    addColumn(columnName: string, dataType: DataTypeExpression, build?: ColumnDefinitionBuilderCallback): ColumnAlteringInterface;
+    /**
+     * Creates an `alter table modify column` query. The `modify column` statement
+     * is only implemeted by MySQL and oracle AFAIK. On other databases you
+     * should use the `alterColumn` method.
+     */
+    modifyColumn(columnName: string, dataType: DataTypeExpression, build: ColumnDefinitionBuilderCallback): ColumnAlteringInterface;
+}
+export declare class AlterTableColumnAlteringBuilder implements ColumnAlteringInterface, OperationNodeSource, Compilable {
+    #private;
+    constructor(props: AlterTableColumnAlteringBuilderProps);
+    alterColumn(column: string, alteration: AlterColumnBuilderCallback): AlterTableColumnAlteringBuilder;
+    dropColumn(column: string, build?: DropColumnBuilderCallback): AlterTableColumnAlteringBuilder;
+    renameColumn(column: string, newColumn: string): AlterTableColumnAlteringBuilder;
+    /**
+     * See {@link CreateTableBuilder.addColumn}
+     */
+    addColumn(columnName: string, dataType: DataTypeExpression, build?: ColumnDefinitionBuilderCallback): AlterTableColumnAlteringBuilder;
+    /**
+     * Creates an `alter table modify column` query. The `modify column` statement
+     * is only implemeted by MySQL and oracle AFAIK. On other databases you
+     * should use the `alterColumn` method.
+     */
+    modifyColumn(columnName: string, dataType: DataTypeExpression, build?: ColumnDefinitionBuilderCallback): AlterTableColumnAlteringBuilder;
+    toOperationNode(): AlterTableNode;
+    compile(): CompiledQuery;
+    execute(options?: AbortableQueryOptions): Promise<void>;
+}
+export interface AlterTableColumnAlteringBuilderProps extends AlterTableBuilderProps {
+}

package/dist/schema/alter-table-builder.js

@@ -0,0 +1,269 @@
+/// <reference types="./alter-table-builder.d.ts" />
+import { AddColumnNode } from '../operation-node/add-column-node.js';
+import { AlterTableNode } from '../operation-node/alter-table-node.js';
+import { ColumnDefinitionNode } from '../operation-node/column-definition-node.js';
+import { DropColumnNode } from '../operation-node/drop-column-node.js';
+import { IdentifierNode } from '../operation-node/identifier-node.js';
+import { RenameColumnNode } from '../operation-node/rename-column-node.js';
+import { freeze, isString, noop } from '../util/object-utils.js';
+import { ColumnDefinitionBuilder, } from './column-definition-builder.js';
+import { ModifyColumnNode } from '../operation-node/modify-column-node.js';
+import { parseDataTypeExpression, } from '../parser/data-type-parser.js';
+import { ForeignKeyConstraintBuilder, } from './foreign-key-constraint-builder.js';
+import { AddConstraintNode } from '../operation-node/add-constraint-node.js';
+import { UniqueConstraintNode } from '../operation-node/unique-constraint-node.js';
+import { CheckConstraintNode } from '../operation-node/check-constraint-node.js';
+import { ForeignKeyConstraintNode } from '../operation-node/foreign-key-constraint-node.js';
+import { ColumnNode } from '../operation-node/column-node.js';
+import { parseTable } from '../parser/table-parser.js';
+import { DropConstraintNode } from '../operation-node/drop-constraint-node.js';
+import { AlterColumnBuilder, } from './alter-column-builder.js';
+import { AlterTableExecutor } from './alter-table-executor.js';
+import { AlterTableAddForeignKeyConstraintBuilder } from './alter-table-add-foreign-key-constraint-builder.js';
+import { AlterTableDropConstraintBuilder } from './alter-table-drop-constraint-builder.js';
+import { PrimaryKeyConstraintNode } from '../operation-node/primary-key-constraint-node.js';
+import { DropIndexNode } from '../operation-node/drop-index-node.js';
+import { AddIndexNode } from '../operation-node/add-index-node.js';
+import { AlterTableAddIndexBuilder } from './alter-table-add-index-builder.js';
+import { UniqueConstraintNodeBuilder, } from './unique-constraint-builder.js';
+import { PrimaryKeyConstraintBuilder, } from './primary-key-constraint-builder.js';
+import { CheckConstraintBuilder, } from './check-constraint-builder.js';
+import { RenameConstraintNode } from '../operation-node/rename-constraint-node.js';
+import { parseExpression, } from '../parser/expression-parser.js';
+import { DropColumnBuilder, } from './drop-column-builder.js';
+/**
+ * This builder can be used to create a `alter table` query.
+ */
+export class AlterTableBuilder {
+    #props;
+    constructor(props) {
+        this.#props = freeze(props);
+    }
+    renameTo(newTableName) {
+        return new AlterTableExecutor({
+            ...this.#props,
+            node: AlterTableNode.cloneWithTableProps(this.#props.node, {
+                renameTo: parseTable(newTableName),
+            }),
+        });
+    }
+    setSchema(newSchema) {
+        return new AlterTableExecutor({
+            ...this.#props,
+            node: AlterTableNode.cloneWithTableProps(this.#props.node, {
+                setSchema: IdentifierNode.create(newSchema),
+            }),
+        });
+    }
+    alterColumn(column, alteration) {
+        const builder = alteration(new AlterColumnBuilder(column));
+        return new AlterTableColumnAlteringBuilder({
+            ...this.#props,
+            node: AlterTableNode.cloneWithColumnAlteration(this.#props.node, builder.toOperationNode()),
+        });
+    }
+    dropColumn(column, build = noop) {
+        const builder = build(new DropColumnBuilder({ node: DropColumnNode.create(column) }));
+        return new AlterTableColumnAlteringBuilder({
+            ...this.#props,
+            node: AlterTableNode.cloneWithColumnAlteration(this.#props.node, builder.toOperationNode()),
+        });
+    }
+    renameColumn(column, newColumn) {
+        return new AlterTableColumnAlteringBuilder({
+            ...this.#props,
+            node: AlterTableNode.cloneWithColumnAlteration(this.#props.node, RenameColumnNode.create(column, newColumn)),
+        });
+    }
+    addColumn(columnName, dataType, build = noop) {
+        const builder = build(new ColumnDefinitionBuilder(ColumnDefinitionNode.create(columnName, parseDataTypeExpression(dataType))));
+        return new AlterTableColumnAlteringBuilder({
+            ...this.#props,
+            node: AlterTableNode.cloneWithColumnAlteration(this.#props.node, AddColumnNode.create(builder.toOperationNode())),
+        });
+    }
+    modifyColumn(columnName, dataType, build = noop) {
+        const builder = build(new ColumnDefinitionBuilder(ColumnDefinitionNode.create(columnName, parseDataTypeExpression(dataType))));
+        return new AlterTableColumnAlteringBuilder({
+            ...this.#props,
+            node: AlterTableNode.cloneWithColumnAlteration(this.#props.node, ModifyColumnNode.create(builder.toOperationNode())),
+        });
+    }
+    /**
+     * See {@link CreateTableBuilder.addUniqueConstraint}
+     */
+    addUniqueConstraint(constraintName, columns, build = noop) {
+        const uniqueConstraintBuilder = build(new UniqueConstraintNodeBuilder(UniqueConstraintNode.create(columns.map((column) => isString(column)
+            ? ColumnNode.create(column)
+            : parseExpression(column)), constraintName)));
+        return new AlterTableExecutor({
+            ...this.#props,
+            node: AlterTableNode.cloneWithTableProps(this.#props.node, {
+                addConstraint: AddConstraintNode.create(uniqueConstraintBuilder.toOperationNode()),
+            }),
+        });
+    }
+    /**
+     * See {@link CreateTableBuilder.addCheckConstraint}
+     */
+    addCheckConstraint(constraintName, checkExpression, build = noop) {
+        const constraintBuilder = build(new CheckConstraintBuilder(CheckConstraintNode.create(checkExpression.toOperationNode(), constraintName)));
+        return new AlterTableExecutor({
+            ...this.#props,
+            node: AlterTableNode.cloneWithTableProps(this.#props.node, {
+                addConstraint: AddConstraintNode.create(constraintBuilder.toOperationNode()),
+            }),
+        });
+    }
+    /**
+     * See {@link CreateTableBuilder.addForeignKeyConstraint}
+     *
+     * Unlike {@link CreateTableBuilder.addForeignKeyConstraint} this method returns
+     * the constraint builder and doesn't take a callback as the last argument. This
+     * is because you can only add one column per `ALTER TABLE` query.
+     */
+    addForeignKeyConstraint(constraintName, columns, targetTable, targetColumns, build = noop) {
+        const constraintBuilder = build(new ForeignKeyConstraintBuilder(ForeignKeyConstraintNode.create(columns.map(ColumnNode.create), parseTable(targetTable), targetColumns.map(ColumnNode.create), constraintName)));
+        return new AlterTableAddForeignKeyConstraintBuilder({
+            ...this.#props,
+            constraintBuilder,
+        });
+    }
+    /**
+     * See {@link CreateTableBuilder.addPrimaryKeyConstraint}
+     */
+    addPrimaryKeyConstraint(constraintName, columns, build = noop) {
+        const constraintBuilder = build(new PrimaryKeyConstraintBuilder(PrimaryKeyConstraintNode.create(columns, constraintName)));
+        return new AlterTableExecutor({
+            ...this.#props,
+            node: AlterTableNode.cloneWithTableProps(this.#props.node, {
+                addConstraint: AddConstraintNode.create(constraintBuilder.toOperationNode()),
+            }),
+        });
+    }
+    dropConstraint(constraintName) {
+        return new AlterTableDropConstraintBuilder({
+            ...this.#props,
+            node: AlterTableNode.cloneWithTableProps(this.#props.node, {
+                dropConstraint: DropConstraintNode.create(constraintName),
+            }),
+        });
+    }
+    renameConstraint(oldName, newName) {
+        return new AlterTableDropConstraintBuilder({
+            ...this.#props,
+            node: AlterTableNode.cloneWithTableProps(this.#props.node, {
+                renameConstraint: RenameConstraintNode.create(oldName, newName),
+            }),
+        });
+    }
+    /**
+     * This can be used to add index to table.
+     *
+     *  ### Examples
+     *
+     * ```ts
+     * db.schema.alterTable('person')
+     *   .addIndex('person_email_index')
+     *   .column('email')
+     *   .unique()
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (MySQL):
+     *
+     * ```sql
+     * alter table `person` add unique index `person_email_index` (`email`)
+     * ```
+     */
+    addIndex(indexName) {
+        return new AlterTableAddIndexBuilder({
+            ...this.#props,
+            node: AlterTableNode.cloneWithTableProps(this.#props.node, {
+                addIndex: AddIndexNode.create(indexName),
+            }),
+        });
+    }
+    /**
+     * This can be used to drop index from table.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.schema.alterTable('person')
+     *   .dropIndex('person_email_index')
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (MySQL):
+     *
+     * ```sql
+     * alter table `person` drop index `test_first_name_index`
+     * ```
+     */
+    dropIndex(indexName) {
+        return new AlterTableExecutor({
+            ...this.#props,
+            node: AlterTableNode.cloneWithTableProps(this.#props.node, {
+                dropIndex: DropIndexNode.create(indexName),
+            }),
+        });
+    }
+    /**
+     * Calls the given function passing `this` as the only argument.
+     *
+     * See {@link CreateTableBuilder.$call}
+     */
+    $call(func) {
+        return func(this);
+    }
+}
+export class AlterTableColumnAlteringBuilder {
+    #props;
+    constructor(props) {
+        this.#props = freeze(props);
+    }
+    alterColumn(column, alteration) {
+        const builder = alteration(new AlterColumnBuilder(column));
+        return new AlterTableColumnAlteringBuilder({
+            ...this.#props,
+            node: AlterTableNode.cloneWithColumnAlteration(this.#props.node, builder.toOperationNode()),
+        });
+    }
+    dropColumn(column, build = noop) {
+        const builder = build(new DropColumnBuilder({ node: DropColumnNode.create(column) }));
+        return new AlterTableColumnAlteringBuilder({
+            ...this.#props,
+            node: AlterTableNode.cloneWithColumnAlteration(this.#props.node, builder.toOperationNode()),
+        });
+    }
+    renameColumn(column, newColumn) {
+        return new AlterTableColumnAlteringBuilder({
+            ...this.#props,
+            node: AlterTableNode.cloneWithColumnAlteration(this.#props.node, RenameColumnNode.create(column, newColumn)),
+        });
+    }
+    addColumn(columnName, dataType, build = noop) {
+        const builder = build(new ColumnDefinitionBuilder(ColumnDefinitionNode.create(columnName, parseDataTypeExpression(dataType))));
+        return new AlterTableColumnAlteringBuilder({
+            ...this.#props,
+            node: AlterTableNode.cloneWithColumnAlteration(this.#props.node, AddColumnNode.create(builder.toOperationNode())),
+        });
+    }
+    modifyColumn(columnName, dataType, build = noop) {
+        const builder = build(new ColumnDefinitionBuilder(ColumnDefinitionNode.create(columnName, parseDataTypeExpression(dataType))));
+        return new AlterTableColumnAlteringBuilder({
+            ...this.#props,
+            node: AlterTableNode.cloneWithColumnAlteration(this.#props.node, ModifyColumnNode.create(builder.toOperationNode())),
+        });
+    }
+    toOperationNode() {
+        return this.#props.executor.transformQuery(this.#props.node, this.#props.queryId);
+    }
+    compile() {
+        return this.#props.executor.compileQuery(this.toOperationNode(), this.#props.queryId);
+    }
+    async execute(options) {
+        await this.#props.executor.executeQuery(this.compile(), options);
+    }
+}

package/dist/schema/alter-table-drop-constraint-builder.d.ts

@@ -0,0 +1,27 @@
+import { AlterTableNode } from '../operation-node/alter-table-node.js';
+import type { OperationNodeSource } from '../operation-node/operation-node-source.js';
+import type { CompiledQuery } from '../query-compiler/compiled-query.js';
+import type { QueryExecutor } from '../query-executor/query-executor.js';
+import type { AbortableQueryOptions } from '../util/abort.js';
+import type { Compilable } from '../util/compilable.js';
+import type { QueryId } from '../util/query-id.js';
+export declare class AlterTableDropConstraintBuilder implements OperationNodeSource, Compilable {
+    #private;
+    constructor(props: AlterTableDropConstraintBuilderProps);
+    ifExists(): AlterTableDropConstraintBuilder;
+    cascade(): AlterTableDropConstraintBuilder;
+    restrict(): AlterTableDropConstraintBuilder;
+    /**
+     * Simply calls the provided function passing `this` as the only argument. `$call` returns
+     * what the provided function returns.
+     */
+    $call<T>(func: (qb: this) => T): T;
+    toOperationNode(): AlterTableNode;
+    compile(): CompiledQuery;
+    execute(options?: AbortableQueryOptions): Promise<void>;
+}
+export interface AlterTableDropConstraintBuilderProps {
+    readonly queryId: QueryId;
+    readonly executor: QueryExecutor;
+    readonly node: AlterTableNode;
+}

package/dist/schema/alter-table-drop-constraint-builder.js

@@ -0,0 +1,56 @@
+/// <reference types="./alter-table-drop-constraint-builder.d.ts" />
+import { AlterTableNode } from '../operation-node/alter-table-node.js';
+import { DropConstraintNode } from '../operation-node/drop-constraint-node.js';
+import { freeze } from '../util/object-utils.js';
+export class AlterTableDropConstraintBuilder {
+    #props;
+    constructor(props) {
+        this.#props = freeze(props);
+    }
+    ifExists() {
+        return new AlterTableDropConstraintBuilder({
+            ...this.#props,
+            node: AlterTableNode.cloneWithTableProps(this.#props.node, {
+                dropConstraint: DropConstraintNode.cloneWith(this.#props.node.dropConstraint, {
+                    ifExists: true,
+                }),
+            }),
+        });
+    }
+    cascade() {
+        return new AlterTableDropConstraintBuilder({
+            ...this.#props,
+            node: AlterTableNode.cloneWithTableProps(this.#props.node, {
+                dropConstraint: DropConstraintNode.cloneWith(this.#props.node.dropConstraint, {
+                    modifier: 'cascade',
+                }),
+            }),
+        });
+    }
+    restrict() {
+        return new AlterTableDropConstraintBuilder({
+            ...this.#props,
+            node: AlterTableNode.cloneWithTableProps(this.#props.node, {
+                dropConstraint: DropConstraintNode.cloneWith(this.#props.node.dropConstraint, {
+                    modifier: 'restrict',
+                }),
+            }),
+        });
+    }
+    /**
+     * 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.#props.executor.transformQuery(this.#props.node, this.#props.queryId);
+    }
+    compile() {
+        return this.#props.executor.compileQuery(this.toOperationNode(), this.#props.queryId);
+    }
+    async execute(options) {
+        await this.#props.executor.executeQuery(this.compile(), options);
+    }
+}

package/dist/schema/alter-table-executor.d.ts

@@ -0,0 +1,19 @@
+import type { AlterTableNode } from '../operation-node/alter-table-node.js';
+import type { OperationNodeSource } from '../operation-node/operation-node-source.js';
+import type { CompiledQuery } from '../query-compiler/compiled-query.js';
+import type { QueryExecutor } from '../query-executor/query-executor.js';
+import type { AbortableQueryOptions } from '../util/abort.js';
+import type { Compilable } from '../util/compilable.js';
+import type { QueryId } from '../util/query-id.js';
+export declare class AlterTableExecutor implements OperationNodeSource, Compilable {
+    #private;
+    constructor(props: AlterTableExecutorProps);
+    toOperationNode(): AlterTableNode;
+    compile(): CompiledQuery;
+    execute(options?: AbortableQueryOptions): Promise<void>;
+}
+export interface AlterTableExecutorProps {
+    readonly queryId: QueryId;
+    readonly executor: QueryExecutor;
+    readonly node: AlterTableNode;
+}