feat: Alter type builder

Author: lucianolix

src/index.ts

@@ -219,6 +219,8 @@ export * from './operation-node/values-node.js'
 export * from './operation-node/when-node.js'
 export * from './operation-node/where-node.js'
 export * from './operation-node/with-node.js'
+export * from './operation-node/alter-type-node.js'
+export * from './operation-node/add-value-node.js'
 
 export * from './util/column-type.js'
 export * from './util/compilable.js'

src/operation-node/add-value-node.ts

@@ -0,0 +1,38 @@
+import { OperationNode } from './operation-node.js'
+import { freeze } from '../util/object-utils.js'
+import { ValueNode } from './value-node.js'
+
+export type AddValueNodeProps = Omit<AddValueNode, 'kind' | 'value'>
+
+export interface AddValueNode extends OperationNode {
+  readonly kind: 'AddValueNode'
+  readonly value: ValueNode
+  ifNotExists?: boolean
+  before?: ValueNode
+  after?: ValueNode
+}
+
+/**
+ * @internal
+ */
+export const AddValueNode = freeze({
+  is(node: OperationNode): node is AddValueNode {
+    return node.kind === 'AddValueNode'
+  },
+  create(value: ValueNode): AddValueNode {
+    return freeze({
+      kind: 'AddValueNode',
+      value,
+    })
+  },
+
+  cloneWithAddValueProps(
+    node: AddValueNode,
+    props: AddValueNodeProps,
+  ): AddValueNode {
+    return freeze({
+      ...node,
+      ...props,
+    })
+  },
+})

src/operation-node/alter-type-node.ts

@@ -0,0 +1,43 @@
+import { OperationNode } from './operation-node.js'
+import { freeze } from '../util/object-utils.js'
+import { SchemableIdentifierNode } from './schemable-identifier-node.js'
+import { IdentifierNode } from './identifier-node.js'
+import { AddValueNode } from './add-value-node.js'
+import { ValueNode } from './value-node.js'
+
+export type AlterTypeNodeProps = Omit<AlterTypeNode, 'kind' | 'name'>
+
+export interface AlterTypeNode extends OperationNode {
+  readonly kind: 'AlterTypeNode'
+  readonly name: SchemableIdentifierNode
+  renameTo?: IdentifierNode
+  ownerTo?: IdentifierNode
+  setSchema?: IdentifierNode
+  addValue?: AddValueNode
+  renameValueOldName?: ValueNode
+  renameValueNewName?: ValueNode
+}
+
+/**
+ * @internal
+ */
+export const AlterTypeNode = freeze({
+  is(node: OperationNode): node is AlterTypeNode {
+    return node.kind === 'AlterTypeNode'
+  },
+  create(name: SchemableIdentifierNode): AlterTypeNode {
+    return freeze({
+      kind: 'AlterTypeNode',
+      name,
+    })
+  },
+  cloneWithAlterTypeProps(
+    node: AlterTypeNode,
+    props: AlterTypeNodeProps,
+  ): AlterTypeNode {
+    return freeze({
+      ...node,
+      ...props,
+    })
+  },
+})

src/operation-node/operation-node-transformer.ts

@@ -99,7 +99,8 @@ import { OrActionNode } from './or-action-node.js'
 import { CollateNode } from './collate-node.js'
 import { QueryId } from '../util/query-id.js'
 import { RenameConstraintNode } from './rename-constraint-node.js'
-
+import { AlterTypeNode } from './alter-type-node.js'
+import { AddValueNode } from './add-value-node.js'
 /**
  * Transforms an operation node tree into another one.
  *
@@ -242,6 +243,8 @@ export class OperationNodeTransformer {
     OutputNode: this.transformOutput.bind(this),
     OrActionNode: this.transformOrAction.bind(this),
     CollateNode: this.transformCollate.bind(this),
+    AlterTypeNode: this.transformAlterType.bind(this),
+    AddValueNode: this.transformAddValue.bind(this),
   })
 
   transformNode<T extends OperationNode | undefined>(
@@ -1353,4 +1356,32 @@ export class OperationNodeTransformer {
     // An Object.freezed leaf node. No need to clone.
     return node
   }
+
+  protected transformAlterType(
+    node: AlterTypeNode,
+    queryId?: QueryId,
+  ): AlterTypeNode {
+    return requireAllProps<AlterTypeNode>({
+      kind: 'AlterTypeNode',
+      name: this.transformNode(node.name, queryId),
+      ownerTo: this.transformNode(node.ownerTo, queryId),
+      renameTo: this.transformNode(node.renameTo, queryId),
+      renameValueNewName: this.transformNode(node.renameValueNewName, queryId),
+      renameValueOldName: this.transformNode(node.renameValueOldName, queryId),
+      setSchema: this.transformNode(node.setSchema, queryId),
+      addValue: this.transformNode(node.addValue),
+    })
+  }
+  protected transformAddValue(
+    node: AddValueNode,
+    queryId?: QueryId,
+  ): AddValueNode {
+    return requireAllProps<AddValueNode>({
+      kind: 'AddValueNode',
+      value: this.transformNode(node.value, queryId),
+      ifNotExists: node.ifNotExists,
+      before: this.transformNode(node.before, queryId),
+      after: this.transformNode(node.after, queryId),
+    })
+  }
 }

src/operation-node/operation-node-visitor.ts

@@ -100,7 +100,8 @@ import { RefreshMaterializedViewNode } from './refresh-materialized-view-node.js
 import { OrActionNode } from './or-action-node.js'
 import { CollateNode } from './collate-node.js'
 import { RenameConstraintNode } from './rename-constraint-node.js'
-
+import { AlterTypeNode } from './alter-type-node.js'
+import { AddValueNode } from './add-value-node.js'
 export abstract class OperationNodeVisitor {
   protected readonly nodeStack: OperationNode[] = []
 
@@ -207,6 +208,8 @@ export abstract class OperationNodeVisitor {
     OutputNode: this.visitOutput.bind(this),
     OrActionNode: this.visitOrAction.bind(this),
     CollateNode: this.visitCollate.bind(this),
+    AlterTypeNode: this.visitAlterType.bind(this),
+    AddValueNode: this.visitAddValue.bind(this),
   })
 
   protected readonly visitNode = (node: OperationNode): void => {
@@ -324,4 +327,6 @@ export abstract class OperationNodeVisitor {
   protected abstract visitOutput(node: OutputNode): void
   protected abstract visitOrAction(node: OrActionNode): void
   protected abstract visitCollate(node: CollateNode): void
+  protected abstract visitAlterType(node: AlterTypeNode): void
+  protected abstract visitAddValue(node: AddValueNode): void
 }

src/operation-node/operation-node.ts

@@ -96,6 +96,8 @@ export type OperationNodeKind =
   | 'OrActionNode'
   | 'CollateNode'
   | 'RenameConstraintNode'
+  | 'AlterTypeNode'
+  | 'AddValueNode'
 
 export interface OperationNode {
   readonly kind: OperationNodeKind

src/plugin/with-schema/with-schema-transformer.ts

@@ -37,6 +37,7 @@ const ROOT_OPERATION_NODES: Record<RootOperationNode['kind'], true> = freeze({
   SelectQueryNode: true,
   UpdateQueryNode: true,
   MergeQueryNode: true,
+  AlterTypeNode: true,
 })
 
 const SCHEMALESS_FUNCTIONS: Record<string, true> = {

src/query-compiler/default-query-compiler.ts

@@ -117,6 +117,8 @@ import { logOnce } from '../util/log-once.js'
 import { CollateNode } from '../operation-node/collate-node.js'
 import { QueryId } from '../util/query-id.js'
 import { RenameConstraintNode } from '../operation-node/rename-constraint-node.js'
+import { AlterTypeNode } from '../operation-node/alter-type-node.js'
+import { AddValueNode } from '../operation-node/add-value-node.js'
 
 const LIT_WRAP_REGEX = /'/g
 
@@ -1431,6 +1433,55 @@ export class DefaultQueryCompiler
     this.visitNode(node.name)
   }
 
+  protected override visitAlterType(node: AlterTypeNode): void {
+    this.append('alter type ')
+    this.visitNode(node.name)
+    this.append(' ')
+
+    if (node.ownerTo) {
+      this.append('owner to ')
+      this.visitNode(node.ownerTo)
+    }
+
+    if (node.renameTo) {
+      this.append('rename to ')
+      this.visitNode(node.renameTo)
+    }
+
+    if (node.setSchema) {
+      this.append('set schema ')
+      this.visitNode(node.setSchema)
+    }
+
+    if (node.renameValueOldName && node.renameValueNewName) {
+      this.append('rename value ')
+      this.visitNode(node.renameValueOldName)
+      this.append(' ')
+      this.append('to ')
+      this.visitNode(node.renameValueNewName)
+    }
+
+    if (node.addValue) {
+      this.visitNode(node.addValue)
+    }
+  }
+
+  protected override visitAddValue(node: AddValueNode): void {
+    this.append('add value ')
+    if (node.ifNotExists) {
+      this.append('if not exists ')
+    }
+    this.visitNode(node.value)
+    if (node.before) {
+      this.append(' before ')
+      this.visitNode(node.before)
+    }
+    if (node.after) {
+      this.append(' after ')
+      this.visitNode(node.after)
+    }
+  }
+
   protected override visitExplain(node: ExplainNode): void {
     this.append('explain')
 

src/query-compiler/query-compiler.ts

@@ -1,4 +1,5 @@
 import { AlterTableNode } from '../operation-node/alter-table-node.js'
+import { AlterTypeNode } from '../operation-node/alter-type-node.js'
 import { CreateIndexNode } from '../operation-node/create-index-node.js'
 import { CreateSchemaNode } from '../operation-node/create-schema-node.js'
 import { CreateTableNode } from '../operation-node/create-table-node.js'
@@ -31,6 +32,7 @@ export type RootOperationNode =
   | RawNode
   | CreateTypeNode
   | DropTypeNode
+  | AlterTypeNode
   | MergeQueryNode
 
 /**

src/schema/alter-type-add-value-builder.ts

@@ -0,0 +1,71 @@
+import { OperationNodeSource } from '../operation-node/operation-node-source.js'
+import { AddValueNode } from '../operation-node/add-value-node.js'
+import { ValueNode } from '../operation-node/value-node.js'
+
+export class AlterTypeAddValueBuilder implements OperationNodeSource {
+  readonly #node: AddValueNode
+
+  constructor(node: AddValueNode) {
+    this.#node = node
+  }
+
+  /**
+   * Avoids the query throwing an error if the value already exists inside the enum type.
+   *
+   * ### Examples
+   *
+   * ```ts
+   * db.schema.alterType('species').renameValue('cat', 'dog').execute()
+   * ```
+   */
+  ifNotExists() {
+    return new AlterTypeAddValueBuilder(
+      AddValueNode.cloneWithAddValueProps(this.#node, {
+        ifNotExists: true,
+      }),
+    )
+  }
+
+  /**
+   * Adds the new value before the specified existing value.
+   *
+   * ### Examples
+   *
+   * ```ts
+   * db.schema.alterType('species').renameValue('cat', 'dog').execute()
+   * ```
+   */
+  before(value: string) {
+    return new AlterTypeAddValueBuilder(
+      AddValueNode.cloneWithAddValueProps(this.#node, {
+        before: ValueNode.createImmediate(value),
+        after: undefined, // before and after are mutually exclusive
+      }),
+    )
+  }
+  /**
+   * Adds the new value after the specified existing value.
+   *
+   * ### Examples
+   *
+   * ```ts
+   * db.schema.alterType('species').renameValue('cat', 'dog').execute()
+   * ```
+   */
+  after(value: string) {
+    return new AlterTypeAddValueBuilder(
+      AddValueNode.cloneWithAddValueProps(this.#node, {
+        after: ValueNode.createImmediate(value),
+        before: undefined, // before and after are mutually exclusive
+      }),
+    )
+  }
+
+  toOperationNode(): AddValueNode {
+    return this.#node
+  }
+}
+
+export type AlterTypeAddValueCallback = (
+  builder: AlterTypeAddValueBuilder,
+) => AlterTypeAddValueBuilder