effect-qb 0.16.0 → 0.19.0

package/src/internal/dialect.ts

@@ -1,6 +1,9 @@
 import type * as Schema from "effect/Schema"
 
+import type * as QueryAst from "./query-ast.js"
+import type { Projection } from "./projections.js"
 import type * as Expression from "./scalar.js"
+import type * as Casing from "./casing.js"
 
 /**
  * Mutable rendering state shared while serializing SQL for a concrete dialect.
@@ -11,12 +14,20 @@ import type * as Expression from "./scalar.js"
 export interface RenderState {
   readonly params: unknown[]
   readonly valueMappings?: Expression.DriverValueMappings
+  readonly casing?: Casing.Options
   readonly ctes: {
     readonly name: string
     readonly sql: string
     readonly recursive?: boolean
   }[]
   readonly cteNames: Set<string>
+  readonly cteSources: Map<string, unknown>
+  readonly sourceNames?: Map<string, {
+    readonly tableName: string
+    readonly columns: ReadonlyMap<string, string>
+  }>
+  readonly rowLocalColumns?: boolean
+  readonly allowExcluded?: boolean
 }
 
 export interface RenderValueContext {
@@ -25,6 +36,22 @@ export interface RenderValueContext {
   readonly driverValueMapping?: Expression.DriverValueMapping
 }
 
+export const quoteDoubleQuotedIdentifier = (value: string): string => {
+  return `"${value.replaceAll("\"", "\"\"")}"`
+}
+
+export const quoteBacktickIdentifier = (value: string): string => {
+  return `\`${value.replaceAll("`", "``")}\``
+}
+
+export const renderDbTypeName = (value: string): string =>
+  value
+
+export interface RenderedAst {
+  readonly sql: string
+  readonly projections: readonly Projection[]
+}
+
 /**
  * Minimal runtime contract for a SQL dialect.
  *
@@ -38,4 +65,14 @@ export interface SqlDialect<Name extends string = string> {
   renderLiteral(value: unknown, state: RenderState, context?: RenderValueContext): string
   renderTableReference(tableName: string, baseTableName: string, schemaName?: string): string
   renderConcat(values: readonly string[]): string
+  renderQueryAst(
+    ast: QueryAst.Ast<Record<string, unknown>, any, QueryAst.QueryStatement>,
+    state: RenderState,
+    dialect: SqlDialect<Name>
+  ): RenderedAst
+  renderExpression(
+    expression: Expression.Any,
+    state: RenderState,
+    dialect: SqlDialect<Name>
+  ): string
 }

package/src/internal/dsl-mutation-runtime.ts

@@ -1,7 +1,11 @@
 import * as Expression from "./scalar.js"
 import * as Plan from "./row-set.js"
+import { normalizeStatementFlag } from "./dsl-transaction-ddl-runtime.js"
 
 type DslMutationRuntimeContext = {
+  readonly profile: {
+    readonly dialect: string
+  }
   readonly makePlan: (...args: readonly any[]) => any
   readonly getAst: (plan: any) => any
   readonly getQueryState: (plan: any) => any
@@ -14,11 +18,21 @@ type DslMutationRuntimeContext = {
   readonly buildConflictTarget: (target: any, input: any) => any
   readonly mutationTargetClauses: (target: any) => readonly any[]
   readonly mutationAvailableSources: (target: any) => Record<string, any>
-  readonly normalizeColumnList: (columns: string | readonly string[]) => readonly string[]
+  readonly normalizeConflictColumns: (target: any, columns: string | readonly string[]) => readonly string[]
   readonly targetSourceDetails: (target: any) => { readonly sourceName: string; readonly sourceBaseName: string }
   readonly sourceDetails: (source: any) => { readonly sourceName: string; readonly sourceBaseName: string }
 }
 
+export const expectConflictClause = <
+  Conflict extends {
+    readonly kind: string
+    readonly action: string
+    readonly target?: { readonly kind: string; readonly name?: string }
+  } | undefined
+>(
+  conflict: Conflict
+): Conflict => conflict
+
 export const makeDslMutationRuntime = (ctx: DslMutationRuntimeContext) => {
   const insert = (target: any, values?: Record<string, unknown>) => {
     const { sourceName, sourceBaseName } = ctx.targetSourceDetails(target)
@@ -105,7 +119,7 @@ export const makeDslMutationRuntime = (ctx: DslMutationRuntimeContext) => {
     const columns = ctx.normalizeInsertSelectColumns(selection)
     return ctx.makePlan({
       selection: current.selection,
-      required: ctx.currentRequiredList(sourcePlan[Plan.TypeId].required).filter((name) => name !== sourceName),
+      required: ctx.currentRequiredList(sourcePlan[Plan.TypeId].required),
       available: current.available,
       dialect: current.dialect
     }, {
@@ -125,17 +139,23 @@ export const makeDslMutationRuntime = (ctx: DslMutationRuntimeContext) => {
       const currentAst = ctx.getAst(plan)
       const currentQuery = ctx.getQueryState(plan)
       const insertTarget = currentAst.into!.source
-      const conflictTarget = ctx.buildConflictTarget(insertTarget, target)
+      const conflictTarget = expectConflictClause({
+        kind: "conflict",
+        action: "doNothing",
+        target: ctx.buildConflictTarget(insertTarget, target)
+      }).target
       const updateAssignments = options.update
         ? ctx.buildMutationAssignments(insertTarget, options.update)
         : []
       const updateWhere = options.where === undefined
         ? undefined
         : ctx.toDialectExpression(options.where)
+      const targetWhere = conflictTarget.kind === "columns" ? conflictTarget.where : undefined
       const required = [
         ...ctx.currentRequiredList(current.required),
         ...updateAssignments.flatMap((entry) => Object.keys(entry.value[Expression.TypeId].dependencies)),
-        ...(updateWhere ? Object.keys(updateWhere[Expression.TypeId].dependencies) : [])
+        ...(updateWhere ? Object.keys(updateWhere[Expression.TypeId].dependencies) : []),
+        ...(targetWhere ? Object.keys(targetWhere[Expression.TypeId].dependencies) : [])
       ].filter((name, index, list) =>
         !(name in current.available) && list.indexOf(name) === index)
       return ctx.makePlan({
@@ -215,7 +235,7 @@ export const makeDslMutationRuntime = (ctx: DslMutationRuntimeContext) => {
         kind: "conflict",
         target: {
           kind: "columns",
-          columns: ctx.normalizeColumnList(conflictColumns) as readonly [string, ...string[]]
+          columns: ctx.normalizeConflictColumns(target, conflictColumns) as readonly [string, ...string[]]
         },
         action: updateAssignments.length > 0 ? "doUpdate" : "doNothing",
         values: updateAssignments.length > 0 ? updateAssignments : undefined
@@ -250,6 +270,8 @@ export const makeDslMutationRuntime = (ctx: DslMutationRuntimeContext) => {
   }
 
   const truncate = (target: any, options: { readonly restartIdentity?: boolean; readonly cascade?: boolean } = {}) => {
+    const restartIdentity = normalizeStatementFlag(options.restartIdentity)
+    const cascade = normalizeStatementFlag(options.cascade)
     const { sourceName, sourceBaseName } = ctx.targetSourceDetails(target)
     return ctx.makePlan({
       selection: {},
@@ -267,8 +289,8 @@ export const makeDslMutationRuntime = (ctx: DslMutationRuntimeContext) => {
       },
       truncate: {
         kind: "truncate",
-        restartIdentity: options.restartIdentity ?? false,
-        cascade: options.cascade ?? false
+        restartIdentity,
+        cascade
       },
       where: [],
       having: [],
@@ -284,9 +306,6 @@ export const makeDslMutationRuntime = (ctx: DslMutationRuntimeContext) => {
     const onExpression = ctx.toDialectExpression(on)
     const matched = options.whenMatched
     const notMatched = options.whenNotMatched
-    if (matched && "delete" in matched && "update" in matched) {
-      throw new Error("merge whenMatched cannot specify both update and delete")
-    }
     const matchedPredicate = matched?.predicate ? ctx.toDialectExpression(matched.predicate) : undefined
     const matchedAssignments = matched && "update" in matched && matched.update
       ? ctx.buildMutationAssignments(target, matched.update)

package/src/internal/dsl-plan-runtime.ts

@@ -1,6 +1,5 @@
 import * as Expression from "./scalar.js"
 import * as Plan from "./row-set.js"
-import * as Table from "./table.js"
 
 type DslPlanRuntimeContext = {
   readonly profile: {
@@ -22,7 +21,27 @@ type DslPlanRuntimeContext = {
   readonly attachInsertSource: (plan: any, source: any) => any
 }
 
+type LockMode = "update" | "share" | "lowPriority" | "ignore" | "quick"
+
+export const renderSelectLockMode = (mode: LockMode): string =>
+  mode === "update" ? "for update" : "for share"
+
+export const renderMysqlMutationLockMode = (
+  mode: LockMode,
+  _statement: "update" | "delete"
+): string => {
+  if (mode === "lowPriority") {
+    return " low_priority"
+  }
+  return mode === "ignore" ? " ignore" : " quick"
+}
+
 export const makeDslPlanRuntime = (ctx: DslPlanRuntimeContext) => {
+  const sourceRequiredList = (source: any): readonly string[] =>
+    typeof source === "object" && source !== null && "required" in source
+      ? ctx.currentRequiredList(source.required)
+      : []
+
   const buildSetOperation = (kind: string, all: boolean, left: any, right: any) => {
     const leftState = left[Plan.TypeId]
     const leftAst = ctx.getAst(left)
@@ -92,32 +111,26 @@ export const makeDslPlanRuntime = (ctx: DslPlanRuntimeContext) => {
         return ctx.attachInsertSource(plan, source)
       }
 
-      if (
-        typeof source !== "object" ||
-        source === null ||
-        ("kind" in source && source.kind === "values" && !("name" in source)) ||
-        (!(Table.TypeId in source) && !("name" in source && "baseName" in source))
-      ) {
-        throw new Error("from(...) requires an aliased source in select/update statements")
-      }
-
       const sourceLike = source
       const { sourceName, sourceBaseName } = ctx.sourceDetails(sourceLike)
       const presenceWitnesses = ctx.presenceWitnessesOfSourceLike(sourceLike)
+      const sourceRequired = sourceRequiredList(sourceLike)
 
       if (currentQuery.statement === "select") {
+        const nextAvailable = {
+          [sourceName]: {
+            name: sourceName,
+            mode: "required",
+            baseName: sourceBaseName,
+            _presentFormula: ctx.trueFormula(),
+            _presenceWitnesses: presenceWitnesses
+          }
+        }
         return ctx.makePlan({
           selection: current.selection,
-          required: ctx.currentRequiredList(current.required).filter((name) => name !== sourceName),
-          available: {
-            [sourceName]: {
-              name: sourceName,
-              mode: "required",
-              baseName: sourceBaseName,
-              _presentFormula: ctx.trueFormula(),
-              _presenceWitnesses: presenceWitnesses
-            }
-          },
+          required: [...ctx.currentRequiredList(current.required), ...sourceRequired].filter((name, index, values) =>
+            !(name in nextAvailable) && values.indexOf(name) === index),
+          available: nextAvailable,
           dialect: current.dialect
         }, {
           ...currentAst,
@@ -143,7 +156,8 @@ export const makeDslPlanRuntime = (ctx: DslPlanRuntimeContext) => {
         }
         return ctx.makePlan({
           selection: current.selection,
-          required: ctx.currentRequiredList(current.required).filter((name) => !(name in nextAvailable)),
+          required: [...ctx.currentRequiredList(current.required), ...sourceRequired].filter((name, index, values) =>
+            !(name in nextAvailable) && values.indexOf(name) === index),
           available: nextAvailable,
           dialect: current.dialect
         }, {
@@ -160,7 +174,7 @@ export const makeDslPlanRuntime = (ctx: DslPlanRuntimeContext) => {
         }, currentQuery.assumptions, currentQuery.capabilities, currentQuery.statement)
       }
 
-      throw new Error(`from(...) is not supported for ${currentQuery.statement} statements`)
+      return plan
     }
 
   const having = (predicate: any) =>
@@ -195,6 +209,7 @@ export const makeDslPlanRuntime = (ctx: DslPlanRuntimeContext) => {
       const currentQuery = ctx.getQueryState(plan)
       const { sourceName, sourceBaseName } = ctx.sourceDetails(table)
       const presenceWitnesses = ctx.presenceWitnessesOfSourceLike(table)
+      const sourceRequired = sourceRequiredList(table)
       const nextAvailable = {
         ...current.available,
         [sourceName]: {
@@ -207,7 +222,8 @@ export const makeDslPlanRuntime = (ctx: DslPlanRuntimeContext) => {
       }
       return ctx.makePlan({
         selection: current.selection,
-        required: ctx.currentRequiredList(current.required).filter((name) => !(name in nextAvailable)),
+        required: [...ctx.currentRequiredList(current.required), ...sourceRequired].filter((name, index, values) =>
+          !(name in nextAvailable) && values.indexOf(name) === index),
         available: nextAvailable,
         dialect: current.dialect ?? table[Plan.TypeId]?.dialect ?? table.dialect
       }, {
@@ -230,6 +246,7 @@ export const makeDslPlanRuntime = (ctx: DslPlanRuntimeContext) => {
       const onFormula = ctx.formulaOfExpressionRuntime(onExpression)
       const { sourceName, sourceBaseName } = ctx.sourceDetails(table)
       const presenceWitnesses = ctx.presenceWitnessesOfSourceLike(table)
+      const sourceRequired = sourceRequiredList(table)
       const baseAvailable = (kind === "right" || kind === "full"
         ? Object.fromEntries(
           Object.entries(current.available as Record<string, any>).map(([name, source]) => [name, {
@@ -253,7 +270,7 @@ export const makeDslPlanRuntime = (ctx: DslPlanRuntimeContext) => {
       }
       return ctx.makePlan({
         selection: current.selection,
-        required: [...ctx.currentRequiredList(current.required), ...ctx.extractRequiredFromDialectInputRuntime(on)].filter((name, index, values) =>
+        required: [...ctx.currentRequiredList(current.required), ...sourceRequired, ...ctx.extractRequiredFromDialectInputRuntime(on)].filter((name, index, values) =>
           !(name in nextAvailable) && values.indexOf(name) === index),
         available: nextAvailable,
         dialect: current.dialect ?? table.dialect ?? onExpression[Expression.TypeId].dialect

package/src/internal/dsl-query-runtime.ts

@@ -20,20 +20,12 @@ type DslQueryRuntimeContext = {
 
 export const makeDslQueryRuntime = (ctx: DslQueryRuntimeContext) => {
   const values = (rows: readonly [Record<string, any>, ...Record<string, any>[]]) => {
-    if (rows.length === 0) {
-      throw new Error("values(...) requires at least one row")
-    }
-    const normalizedRows = rows.map((row) => ctx.normalizeValuesRow(row)) as unknown as readonly [
-      Record<string, Expression.Any>,
-      ...Record<string, Expression.Any>[]
-    ]
+    const [first, ...rest] = rows
+    const normalizedRows = [
+      ctx.normalizeValuesRow(first),
+      ...rest.map((row) => ctx.normalizeValuesRow(row))
+    ] satisfies readonly [Record<string, Expression.Any>, ...Record<string, Expression.Any>[]]
     const columnNames = Object.keys(normalizedRows[0]!)
-    for (const row of normalizedRows) {
-      const rowKeys = Object.keys(row)
-      if (rowKeys.length !== columnNames.length || !rowKeys.every((key, index) => key === columnNames[index])) {
-        throw new Error("values(...) rows must project the same columns in the same order")
-      }
-    }
     return Object.assign(Object.create(ctx.ValuesInputProto), {
       kind: "values",
       dialect: ctx.profile.dialect,
@@ -45,20 +37,6 @@ export const makeDslQueryRuntime = (ctx: DslQueryRuntimeContext) => {
   const unnest = (columns: Record<string, readonly any[]>, alias: string) => {
     const normalizedColumns = ctx.normalizeUnnestColumns(columns)
     const columnNames = Object.keys(normalizedColumns)
-    if (columnNames.length === 0) {
-      throw new Error("unnest(...) requires at least one column array")
-    }
-    const firstColumn = normalizedColumns[columnNames[0] as keyof typeof normalizedColumns]
-    const rowCount = firstColumn?.length ?? 0
-    if (rowCount === 0) {
-      throw new Error("unnest(...) requires at least one row")
-    }
-    for (const columnName of columnNames) {
-      const values = normalizedColumns[columnName]!
-      if (values.length !== rowCount) {
-        throw new Error("unnest(...) column arrays must have the same length")
-      }
-    }
     const firstRow = Object.fromEntries(
       columnNames.map((columnName) => [columnName, normalizedColumns[columnName]![0]!])
     ) as Record<string, Expression.Any>
@@ -97,8 +75,8 @@ export const makeDslQueryRuntime = (ctx: DslQueryRuntimeContext) => {
     return Object.assign(source, columns)
   }
 
-  const select = (selection: any) =>
-    ctx.makePlan({
+  const select = (selection: any = {}) => {
+    return ctx.makePlan({
       selection,
       required: ctx.extractRequiredRuntime(selection),
       available: {},
@@ -112,6 +90,7 @@ export const makeDslQueryRuntime = (ctx: DslQueryRuntimeContext) => {
       groupBy: [],
       orderBy: []
     }, undefined, "read", "select")
+  }
 
   const groupBy = (...values: readonly Expression.Any[]) =>
     (plan: any) => {
@@ -132,8 +111,8 @@ export const makeDslQueryRuntime = (ctx: DslQueryRuntimeContext) => {
       }, currentQuery.assumptions, currentQuery.capabilities, currentQuery.statement)
     }
 
-  const returning = (selection: any) =>
-    (plan: any) => {
+  const returning = (selection: any) => {
+    return (plan: any) => {
       const current = plan[Plan.TypeId]
       const currentAst = ctx.getAst(plan)
       const currentQuery = ctx.getQueryState(plan)
@@ -148,6 +127,7 @@ export const makeDslQueryRuntime = (ctx: DslQueryRuntimeContext) => {
         select: selection
       }, currentQuery.assumptions, currentQuery.capabilities, currentQuery.statement, currentQuery.target, currentQuery.insertSource)
     }
+  }
 
   return {
     values,

package/src/internal/dsl-transaction-ddl-runtime.ts

@@ -10,9 +10,44 @@ type DslTransactionDdlRuntimeContext = {
   readonly defaultIndexName: (tableName: string, columns: readonly string[], unique: boolean) => string
 }
 
+export const renderTransactionIsolationLevel = (
+  isolationLevel: unknown
+): string => {
+  if (isolationLevel === undefined) {
+    return ""
+  }
+  return `isolation level ${isolationLevel as string}`
+}
+
+export const expectDdlClauseKind = <
+  Ddl extends { readonly kind: string },
+  Kind extends Ddl["kind"]
+>(
+  ddl: Ddl | undefined,
+  _kind: Kind
+): Extract<Ddl, { readonly kind: Kind }> =>
+  ddl as Extract<Ddl, { readonly kind: Kind }>
+
+export const expectTruncateClause = <
+  Truncate extends { readonly kind: string }
+>(
+  truncate: Truncate | undefined
+): Extract<Truncate, { readonly kind: "truncate" }> =>
+  truncate as Extract<Truncate, { readonly kind: "truncate" }>
+
+export const normalizeStatementFlag = (value: unknown): boolean =>
+  (value as boolean | undefined) ?? false
+
+export const normalizeStatementIdentifier = (
+  _apiName: string,
+  _identifierName: string,
+  value: unknown
+): string =>
+  value as string
+
 export const makeDslTransactionDdlRuntime = (ctx: DslTransactionDdlRuntimeContext) => {
-  const transaction = (options: { readonly isolationLevel?: any; readonly readOnly?: boolean } = {}) =>
-    ctx.makePlan({
+  const transaction = (options: { readonly isolationLevel?: any; readonly readOnly?: boolean } = {}) => {
+    return ctx.makePlan({
       selection: {},
       required: [],
       available: {},
@@ -31,6 +66,7 @@ export const makeDslTransactionDdlRuntime = (ctx: DslTransactionDdlRuntimeContex
       groupBy: [],
       orderBy: []
     }, undefined, "transaction", "transaction")
+  }
 
   const commit = () =>
     ctx.makePlan({
@@ -70,8 +106,8 @@ export const makeDslTransactionDdlRuntime = (ctx: DslTransactionDdlRuntimeContex
       orderBy: []
     }, undefined, "transaction", "rollback")
 
-  const savepoint = (name: string) =>
-    ctx.makePlan({
+  const savepoint = (name: string) => {
+    return ctx.makePlan({
       selection: {},
       required: [],
       available: {},
@@ -89,9 +125,10 @@ export const makeDslTransactionDdlRuntime = (ctx: DslTransactionDdlRuntimeContex
       groupBy: [],
       orderBy: []
     }, undefined, "transaction", "savepoint")
+  }
 
-  const rollbackTo = (name: string) =>
-    ctx.makePlan({
+  const rollbackTo = (name: string) => {
+    return ctx.makePlan({
       selection: {},
       required: [],
       available: {},
@@ -109,9 +146,10 @@ export const makeDslTransactionDdlRuntime = (ctx: DslTransactionDdlRuntimeContex
       groupBy: [],
       orderBy: []
     }, undefined, "transaction", "rollbackTo")
+  }
 
-  const releaseSavepoint = (name: string) =>
-    ctx.makePlan({
+  const releaseSavepoint = (name: string) => {
+    return ctx.makePlan({
       selection: {},
       required: [],
       available: {},
@@ -129,8 +167,10 @@ export const makeDslTransactionDdlRuntime = (ctx: DslTransactionDdlRuntimeContex
       groupBy: [],
       orderBy: []
     }, undefined, "transaction", "releaseSavepoint")
+  }
 
   const createTable = (target: any, options: { readonly ifNotExists?: boolean } = {}) => {
+    const ifNotExists = normalizeStatementFlag(options.ifNotExists)
     const { sourceName, sourceBaseName } = ctx.targetSourceDetails(target)
     return ctx.makePlan({
       selection: {},
@@ -148,7 +188,7 @@ export const makeDslTransactionDdlRuntime = (ctx: DslTransactionDdlRuntimeContex
       },
       ddl: {
         kind: "createTable",
-        ifNotExists: options.ifNotExists ?? false
+        ifNotExists
       },
       where: [],
       having: [],
@@ -159,6 +199,7 @@ export const makeDslTransactionDdlRuntime = (ctx: DslTransactionDdlRuntimeContex
   }
 
   const dropTable = (target: any, options: { readonly ifExists?: boolean } = {}) => {
+    const ifExists = normalizeStatementFlag(options.ifExists)
     const { sourceName, sourceBaseName } = ctx.targetSourceDetails(target)
     return ctx.makePlan({
       selection: {},
@@ -176,7 +217,7 @@ export const makeDslTransactionDdlRuntime = (ctx: DslTransactionDdlRuntimeContex
       },
       ddl: {
         kind: "dropTable",
-        ifExists: options.ifExists ?? false
+        ifExists
       },
       where: [],
       having: [],
@@ -188,6 +229,9 @@ export const makeDslTransactionDdlRuntime = (ctx: DslTransactionDdlRuntimeContex
 
   const createIndex = (target: any, columns: string | readonly string[], options: { readonly name?: string; readonly unique?: boolean; readonly ifNotExists?: boolean } = {}) => {
     const normalizedColumns = ctx.normalizeColumnList(columns)
+    const unique = normalizeStatementFlag(options.unique)
+    const ifNotExists = normalizeStatementFlag(options.ifNotExists)
+    const name = options.name
     const { sourceName, sourceBaseName } = ctx.targetSourceDetails(target)
     return ctx.makePlan({
       selection: {},
@@ -205,10 +249,10 @@ export const makeDslTransactionDdlRuntime = (ctx: DslTransactionDdlRuntimeContex
       },
       ddl: {
         kind: "createIndex",
-        name: options.name ?? ctx.defaultIndexName(sourceBaseName, normalizedColumns, options.unique ?? false),
+        name: name ?? ctx.defaultIndexName(sourceBaseName, normalizedColumns, unique),
         columns: normalizedColumns,
-        unique: options.unique ?? false,
-        ifNotExists: options.ifNotExists ?? false
+        unique,
+        ifNotExists
       },
       where: [],
       having: [],
@@ -220,6 +264,8 @@ export const makeDslTransactionDdlRuntime = (ctx: DslTransactionDdlRuntimeContex
 
   const dropIndex = (target: any, columns: string | readonly string[], options: { readonly name?: string; readonly ifExists?: boolean } = {}) => {
     const normalizedColumns = ctx.normalizeColumnList(columns)
+    const ifExists = normalizeStatementFlag(options.ifExists)
+    const name = options.name
     const { sourceName, sourceBaseName } = ctx.targetSourceDetails(target)
     return ctx.makePlan({
       selection: {},
@@ -237,8 +283,8 @@ export const makeDslTransactionDdlRuntime = (ctx: DslTransactionDdlRuntimeContex
       },
       ddl: {
         kind: "dropIndex",
-        name: options.name ?? ctx.defaultIndexName(sourceBaseName, normalizedColumns, false),
-        ifExists: options.ifExists ?? false
+        name: name ?? ctx.defaultIndexName(sourceBaseName, normalizedColumns, false),
+        ifExists
       },
       where: [],
       having: [],