effect-qb 0.16.0 → 4.0.0-beta.66

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-qb",
-  "version": "0.16.0",
+  "version": "4.0.0-beta.66",
   "type": "module",
   "license": "MIT",
   "repository": {
@@ -33,11 +33,16 @@
       "types": "./src/mysql.ts",
       "import": "./dist/mysql.js"
     },
+    "./sqlite": {
+      "types": "./src/sqlite.ts",
+      "import": "./dist/sqlite.js"
+    },
     "./package.json": "./package.json"
   },
   "imports": {
     "#postgres": "./src/postgres.ts",
     "#mysql": "./src/mysql.ts",
+    "#sqlite": "./src/sqlite.ts",
     "#internal/*": "./src/internal/*"
   },
   "publishConfig": {
@@ -52,9 +57,7 @@
     "@typescript/native-preview": "beta"
   },
   "dependencies": {
-    "@effect/experimental": "^0.57.0",
-    "@effect/sql": "^0.48.0",
-    "effect": "^3.19.3",
+    "effect": "4.0.0-beta.66",
     "pgsql-ast-parser": "^12.0.2"
   }
 }

package/src/internal/column-state.d.ts

@@ -70,7 +70,7 @@ export interface ColumnState<Select, Insert, Update, Db extends Expression.DbTyp
 export interface ColumnDefinition<Select, Insert, Update, Db extends Expression.DbType.Any, Nullable extends boolean, HasDefault extends boolean, Generated extends boolean, PrimaryKey extends boolean, Unique extends boolean, Ref, Dependencies extends Expression.BindingId = never> extends Pipeable, Expression.Scalar<Select, Db, Nullable extends true ? "maybe" : "never", Db["dialect"], "scalar", Dependencies> {
     readonly pipe: Pipeable["pipe"];
     readonly [ColumnTypeId]: ColumnState<Select, Insert, Update, Db, Nullable, HasDefault, Generated, PrimaryKey, Unique, Ref, Dependencies>;
-    readonly schema: Schema.Schema<NonNullable<Select>, any, any>;
+    readonly schema: Schema.Schema<NonNullable<Select>>;
     readonly metadata: {
         readonly dbType: Db;
         readonly nullable: Nullable;
@@ -111,7 +111,7 @@ export type AnyColumnDefinition = ColumnDefinition<any, any, any, Expression.DbT
 /** Convenience alias for any bound column. */
 export type AnyBoundColumn = BoundColumn<any, any, any, Expression.DbType.Any, boolean, boolean, boolean, boolean, boolean, any, string, string, string>;
 /** Constructs a runtime column-definition object from schema and metadata. */
-export declare const makeColumnDefinition: <Select, Insert, Update, Db extends Expression.DbType.Any, Nullable extends boolean, HasDefault extends boolean, Generated extends boolean, PrimaryKey extends boolean, Unique extends boolean, Ref, Dependencies extends string = never>(schema: Schema.Schema<NonNullable<Select>, any, any>, metadata: {
+export declare const makeColumnDefinition: <Select, Insert, Update, Db extends Expression.DbType.Any, Nullable extends boolean, HasDefault extends boolean, Generated extends boolean, PrimaryKey extends boolean, Unique extends boolean, Ref, Dependencies extends string = never>(schema: Schema.Schema<NonNullable<Select>>, metadata: {
     readonly dbType: Db;
     readonly nullable: Nullable;
     readonly hasDefault: HasDefault;
@@ -135,7 +135,7 @@ export declare const makeColumnDefinition: <Select, Insert, Update, Db extends E
     } | undefined;
 }) => ColumnDefinition<Select, Insert, Update, Db, Nullable, HasDefault, Generated, PrimaryKey, Unique, Ref, Dependencies>;
 export declare const remapColumnDefinition: <Select, Insert, Update, Db extends Expression.DbType.Any, Nullable extends boolean, HasDefault extends boolean, Generated extends boolean, PrimaryKey extends boolean, Unique extends boolean, Ref, Dependencies extends string = never>(column: ColumnDefinition<Select, Insert, Update, Db, Nullable, HasDefault, Generated, PrimaryKey, Unique, Ref, Dependencies>, options?: {
-    readonly schema?: Schema.Schema.Any | undefined;
+    readonly schema?: Schema.Top | undefined;
     readonly metadata?: {
         readonly dbType: Db;
         readonly nullable: Nullable;

package/src/internal/column-state.ts

@@ -123,7 +123,7 @@ export interface ColumnDefinition<
     Ref,
     Dependencies
   >
-  readonly schema: Schema.Schema<NonNullable<Select>, any, any>
+  readonly schema: Schema.Schema<NonNullable<Select>>
   readonly metadata: {
     readonly dbType: Db
     readonly nullable: Nullable
@@ -257,7 +257,7 @@ export const makeColumnDefinition = <
   Ref,
   Dependencies extends Expression.BindingId = never
 >(
-  schema: Schema.Schema<NonNullable<Select>, any, any>,
+  schema: Schema.Schema<NonNullable<Select>>,
   metadata: ColumnDefinition<
     Select,
     Insert,
@@ -345,7 +345,7 @@ export const remapColumnDefinition = <
     Dependencies
   >,
   options: {
-    readonly schema?: Schema.Schema.Any
+    readonly schema?: Schema.Top
     readonly metadata?: ColumnDefinition<
       Select,
       Insert,

package/src/internal/column.ts

@@ -225,21 +225,21 @@ type ForeignKeyOptions<Target extends AnyBoundColumn> = {
 
 type SchemaCompatibleColumn<
   Column extends AnyColumnDefinition,
-  SchemaType extends Schema.Schema.Any
-> = [BaseSelectType<Column>] extends [Schema.Schema.Encoded<SchemaType>]
+  SchemaType extends Schema.Top
+> = [BaseSelectType<Column>] extends [Schema.Codec.Encoded<SchemaType>]
   ? Column
   : never
 
 type ColumnSchemaOutput<
   Column extends AnyColumnDefinition,
-  SchemaType extends Schema.Schema.Any
+  SchemaType extends Schema.Top
 > = IsNullable<Column> extends true
   ? Schema.Schema.Type<SchemaType> | null
   : Schema.Schema.Type<SchemaType>
 
 type ColumnWithSchema<
   Column extends AnyColumnDefinition,
-  SchemaType extends Schema.Schema.Any
+  SchemaType extends Schema.Top
 > = ColumnDefinition<
   ColumnSchemaOutput<Column, SchemaType>,
   ColumnSchemaOutput<Column, SchemaType>,
@@ -376,7 +376,7 @@ const isColumnDefinitionValue = (value: unknown): value is AnyColumnDefinition =
   typeof value === "object" && value !== null && ColumnTypeId in value
 
 const primitive = <Type, Db extends Expression.DbType.Any>(
-  schema: Schema.Schema<Type, any, any>,
+  schema: Schema.Schema<Type>,
   dbType: Db
 ): ColumnDefinition<Type, Type, Type, Db, false, false, false, false, false, undefined> =>
   makeColumnDefinition(schema as Schema.Schema<NonNullable<Type>>, {
@@ -401,7 +401,7 @@ type ColumnModule<
   JsonKind extends string
 > = {
   readonly custom: <
-    SchemaType extends Schema.Schema.Any,
+    SchemaType extends Schema.Top,
     Db extends Expression.DbType.Any
   >(
     schema: SchemaType,
@@ -425,7 +425,7 @@ type ColumnModule<
   readonly boolean: () => ColumnDefinition<boolean, boolean, boolean, Expression.DbType.Base<Dialect, BooleanKind>, false, false, false, false, false, undefined>
   readonly date: () => ColumnDefinition<LocalDateString, LocalDateString, LocalDateString, Expression.DbType.Base<Dialect, DateKind>, false, false, false, false, false, undefined>
   readonly timestamp: () => ColumnDefinition<LocalDateTimeString, LocalDateTimeString, LocalDateTimeString, Expression.DbType.Base<Dialect, TimestampKind>, false, false, false, false, false, undefined>
-  readonly json: <SchemaType extends Schema.Schema.Any>(
+  readonly json: <SchemaType extends Schema.Top>(
     schema: SchemaType
   ) => ColumnDefinition<
     Schema.Schema.Type<SchemaType>,
@@ -442,7 +442,7 @@ type ColumnModule<
 }
 
 /** Replaces a column's runtime schema while preserving its SQL type metadata. */
-export const schema = <SchemaType extends Schema.Schema.Any>(nextSchema: SchemaType) =>
+export const schema = <SchemaType extends Schema.Top>(nextSchema: SchemaType) =>
   <Column extends AnyColumnDefinition>(
     column: SchemaCompatibleColumn<Column, SchemaType>
   ): ColumnWithSchema<Column, SchemaType> =>

package/src/internal/derived-table.ts

@@ -10,11 +10,13 @@ import {
   type LateralSource,
   type QueryPlan,
   getAst,
+  getQueryState,
   makeExpression,
+  currentRequiredList,
   type SelectionOfPlan
 } from "./query.js"
 import * as ExpressionAst from "./expression-ast.js"
-import { flattenSelection } from "./projections.js"
+import { flattenSelection, validateProjections } from "./projections.js"
 
 const DerivedProto = {
   pipe(this: unknown) {
@@ -55,6 +57,24 @@ const setPath = (
 
 const pathAlias = (path: readonly string[]): string => path.join("__")
 
+const assertSourceComplete = (
+  plan: QueryPlan<any, any, any, any, any, any, any, any, any, any>
+): void => {
+  const required = currentRequiredList(plan[Plan.TypeId].required)
+  if (required.length > 0) {
+    throw new Error(`query references sources that are not yet in scope: ${required.join(", ")}`)
+  }
+}
+
+const assertInlineSourceStatement = (
+  plan: QueryPlan<any, any, any, any, any, any, any, any, any, any>
+): void => {
+  const statement = getQueryState(plan).statement
+  if (statement !== "select" && statement !== "set") {
+    throw new Error("inline derived sources only accept select-like query plans")
+  }
+}
+
 const reboundedColumns = <
   PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>,
   Alias extends string
@@ -64,7 +84,9 @@ const reboundedColumns = <
 ): DerivedSelectionOf<SelectionOfPlan<PlanValue>, Alias> => {
   const ast = getAst(plan)
   const selection = {} as Record<string, unknown>
-  for (const projection of flattenSelection(ast.select as Record<string, unknown>)) {
+  const projections = flattenSelection(ast.select as Record<string, unknown>)
+  validateProjections(projections)
+  for (const projection of projections) {
     const expectedAlias = pathAlias(projection.path)
     if (projection.alias !== expectedAlias) {
       throw new Error(
@@ -98,6 +120,8 @@ export const makeDerivedSource = <
   plan: CompletePlan<PlanValue>,
   alias: Alias
 ): DerivedSource<PlanValue, Alias> => {
+  assertInlineSourceStatement(plan)
+  assertSourceComplete(plan)
   const columns = reboundedColumns(plan, alias)
   const derived = attachPipe(Object.create(DerivedProto)) as Record<string, unknown>
   Object.assign(derived, columns)
@@ -119,6 +143,7 @@ export const makeCteSource = <
   alias: Alias,
   recursive = false
 ): CteSource<PlanValue, Alias> => {
+  assertSourceComplete(plan)
   const columns = reboundedColumns(plan, alias)
   const cte = attachPipe(Object.create(DerivedProto)) as Record<string, unknown>
   Object.assign(cte, columns)
@@ -140,6 +165,7 @@ export const makeLateralSource = <
   plan: PlanValue,
   alias: Alias
 ): LateralSource<PlanValue, Alias> => {
+  assertInlineSourceStatement(plan)
   const columns = reboundedColumns(plan, alias)
   const lateral = attachPipe(Object.create(DerivedProto)) as Record<string, unknown>
   Object.assign(lateral, columns)
@@ -148,7 +174,7 @@ export const makeLateralSource = <
   lateral.baseName = alias
   lateral.dialect = plan[Plan.TypeId].dialect
   lateral.plan = plan
-  lateral.required = undefined as never
+  lateral.required = currentRequiredList(plan[Plan.TypeId].required) as never
   lateral.columns = columns
   return lateral as unknown as LateralSource<PlanValue, Alias>
 }

package/src/internal/dialect.ts

@@ -17,11 +17,13 @@ export interface RenderState {
     readonly recursive?: boolean
   }[]
   readonly cteNames: Set<string>
+  readonly cteSources: Map<string, unknown>
+  readonly rowLocalColumns?: boolean
 }
 
 export interface RenderValueContext {
   readonly dbType?: Expression.DbType.Any
-  readonly runtimeSchema?: Schema.Schema.Any
+  readonly runtimeSchema?: Schema.Top
   readonly driverValueMapping?: Expression.DriverValueMapping
 }
 

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 * as Table from "./table.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,13 +18,155 @@ 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 expectInsertSourceKind = <
+  Source extends { readonly kind: string } | undefined
+>(
+  source: Source
+): Source => {
+  if (
+    source !== undefined &&
+    source.kind !== "values" &&
+    source.kind !== "query" &&
+    source.kind !== "unnest"
+  ) {
+    throw new Error("Unsupported insert source kind")
+  }
+  return source
+}
+
+export const expectConflictClause = <
+  Conflict extends {
+    readonly kind: string
+    readonly action: string
+    readonly target?: { readonly kind: string }
+  } | undefined
+>(
+  conflict: Conflict
+): Conflict => {
+  if (conflict === undefined) {
+    return conflict
+  }
+  if (conflict.kind !== "conflict") {
+    throw new Error("Unsupported conflict clause kind")
+  }
+  if (conflict.action !== "doNothing" && conflict.action !== "doUpdate") {
+    throw new Error("Unsupported conflict action")
+  }
+  if (
+    conflict.target !== undefined &&
+    conflict.target.kind !== "columns" &&
+    conflict.target.kind !== "constraint"
+  ) {
+    throw new Error("Unsupported conflict target kind")
+  }
+  return conflict
+}
+
 export const makeDslMutationRuntime = (ctx: DslMutationRuntimeContext) => {
+  const aliasedSourceKinds = new Set(["derived", "cte", "lateral", "values", "unnest", "tableFunction"])
+  const isRecord = (value: unknown): value is Record<PropertyKey, unknown> =>
+    typeof value === "object" && value !== null
+
+  const isTableTarget = (target: unknown): boolean =>
+    typeof target === "object" && target !== null && Table.TypeId in target && Plan.TypeId in target
+
+  const hasColumnRecord = (value: Record<PropertyKey, unknown>): boolean => isRecord(value.columns)
+
+  const isAliasedSource = (source: unknown): boolean => {
+    if (!isRecord(source)) {
+      return false
+    }
+    if (isTableTarget(source)) {
+      return true
+    }
+    if (!("kind" in source) || !("name" in source) || !("baseName" in source)) {
+      return false
+    }
+    if (typeof source.kind !== "string" || !aliasedSourceKinds.has(source.kind)) {
+      return false
+    }
+    if (typeof source.name !== "string" || typeof source.baseName !== "string") {
+      return false
+    }
+    switch (source.kind) {
+      case "derived":
+      case "cte":
+      case "lateral":
+        return isRecord(source.plan) && Plan.TypeId in source.plan && hasColumnRecord(source)
+      case "values":
+        return Array.isArray(source.rows) && hasColumnRecord(source)
+      case "unnest":
+        return isRecord(source.arrays) && hasColumnRecord(source)
+      case "tableFunction":
+        return typeof source.functionName === "string" && Array.isArray(source.args) && hasColumnRecord(source)
+    }
+    return false
+  }
+
+  const assertMutationTarget = (target: unknown, apiName: string): void => {
+    if (!isTableTarget(target)) {
+      throw new Error(`${apiName}(...) requires table targets`)
+    }
+  }
+
+  const assertAliasedSource = (source: unknown, apiName: string): void => {
+    if (!isAliasedSource(source)) {
+      throw new Error(`${apiName}(...) requires an aliased source`)
+    }
+  }
+
+  const assertMutationTargets = (
+    target: unknown,
+    apiName: string,
+    options: { readonly allowMultiple?: boolean } = {}
+  ): void => {
+    const targets = Array.isArray(target) ? target : [target]
+    if (targets.length === 0) {
+      throw new Error(`${apiName}(...) requires at least one table target`)
+    }
+    if (Array.isArray(target) && targets.length === 1) {
+      throw new Error(`${apiName}(...) requires a table target, not a single-element target tuple`)
+    }
+    for (const entry of targets) {
+      assertMutationTarget(entry, apiName)
+    }
+    if (targets.length > 1 && options.allowMultiple !== true) {
+      throw new Error(`${apiName}(...) requires a single table target`)
+    }
+    if (targets.length > 1 && ctx.profile.dialect !== "mysql" && ctx.profile.dialect !== "sqlite") {
+      throw new Error(`${apiName}(...) only supports multiple mutation targets for mysql`)
+    }
+  }
+
+  const assertUniqueTargetNames = (targets: readonly { readonly tableName: string }[]): void => {
+    const seen = new Set<string>()
+    for (const target of targets) {
+      if (seen.has(target.tableName)) {
+        throw new Error(`mutation target source names must be unique: ${target.tableName}`)
+      }
+      seen.add(target.tableName)
+    }
+  }
+
+  const assertInsertSelectSource = (sourcePlan: any, selection: Record<string, unknown>): void => {
+    const statement = ctx.getQueryState(sourcePlan).statement
+    if (statement !== "select" && statement !== "set") {
+      throw new Error("insert sources only accept select-like query plans")
+    }
+    for (const value of Object.values(selection)) {
+      if (value === null || typeof value !== "object" || !(Expression.TypeId in value)) {
+        throw new Error("insert sources require a flat selection object")
+      }
+    }
+  }
+
   const insert = (target: any, values?: Record<string, unknown>) => {
+    assertMutationTargets(target, "insert")
     const { sourceName, sourceBaseName } = ctx.targetSourceDetails(target)
     const assignments = values === undefined
       ? []
@@ -102,10 +248,11 @@ export const makeDslMutationRuntime = (ctx: DslMutationRuntimeContext) => {
 
     const sourcePlan = source
     const selection = sourcePlan[Plan.TypeId].selection as Record<string, Expression.Any>
+    assertInsertSelectSource(sourcePlan, selection)
     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
     }, {
@@ -124,18 +271,26 @@ export const makeDslMutationRuntime = (ctx: DslMutationRuntimeContext) => {
       const current = plan[Plan.TypeId]
       const currentAst = ctx.getAst(plan)
       const currentQuery = ctx.getQueryState(plan)
+      if (currentQuery.statement !== "insert") {
+        throw new Error(`onConflict(...) is not supported for ${currentQuery.statement} statements`)
+      }
       const insertTarget = currentAst.into!.source
       const conflictTarget = ctx.buildConflictTarget(insertTarget, target)
       const updateAssignments = options.update
         ? ctx.buildMutationAssignments(insertTarget, options.update)
         : []
+      if (options.update !== undefined && updateAssignments.length === 0) {
+        throw new Error("conflict update assignments require at least one assignment")
+      }
       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({
@@ -156,7 +311,9 @@ export const makeDslMutationRuntime = (ctx: DslMutationRuntimeContext) => {
     }
 
   const update = (target: any, values: Record<string, unknown>) => {
+    assertMutationTargets(target, "update", { allowMultiple: true })
     const targets = ctx.mutationTargetClauses(target)
+    assertUniqueTargetNames(targets)
     const primaryTarget = targets[0]!
     const assignments = ctx.buildMutationAssignments(target, values)
     const targetNames = new Set(targets.map((entry: any) => entry.tableName))
@@ -183,9 +340,13 @@ export const makeDslMutationRuntime = (ctx: DslMutationRuntimeContext) => {
   }
 
   const upsert = (target: any, values: Record<string, unknown>, conflictColumns: string | readonly string[], updateValues?: Record<string, unknown>) => {
+    assertMutationTargets(target, "upsert")
     const { sourceName, sourceBaseName } = ctx.targetSourceDetails(target)
     const assignments = ctx.buildMutationAssignments(target, values)
     const updateAssignments = updateValues ? ctx.buildMutationAssignments(target, updateValues) : []
+    if (updateValues !== undefined && updateAssignments.length === 0) {
+      throw new Error("upsert update assignments require at least one assignment")
+    }
     const required = [
       ...assignments.flatMap((entry) => Object.keys(entry.value[Expression.TypeId].dependencies)),
       ...updateAssignments.flatMap((entry) => Object.keys(entry.value[Expression.TypeId].dependencies))
@@ -215,7 +376,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
@@ -229,7 +390,9 @@ export const makeDslMutationRuntime = (ctx: DslMutationRuntimeContext) => {
   }
 
   const delete_ = (target: any) => {
+    assertMutationTargets(target, "delete", { allowMultiple: true })
     const targets = ctx.mutationTargetClauses(target)
+    assertUniqueTargetNames(targets)
     const primaryTarget = targets[0]!
     return ctx.makePlan({
       selection: {},
@@ -250,6 +413,7 @@ export const makeDslMutationRuntime = (ctx: DslMutationRuntimeContext) => {
   }
 
   const truncate = (target: any, options: { readonly restartIdentity?: boolean; readonly cascade?: boolean } = {}) => {
+    assertMutationTargets(target, "truncate")
     const { sourceName, sourceBaseName } = ctx.targetSourceDetails(target)
     return ctx.makePlan({
       selection: {},
@@ -279,8 +443,13 @@ export const makeDslMutationRuntime = (ctx: DslMutationRuntimeContext) => {
   }
 
   const merge = (target: any, source: any, on: any, options: any = {}) => {
+    assertMutationTargets(target, "merge")
+    assertAliasedSource(source, "merge")
     const { sourceName: targetName, sourceBaseName: targetBaseName } = ctx.targetSourceDetails(target)
     const { sourceName: usingName, sourceBaseName: usingBaseName } = ctx.sourceDetails(source)
+    if (targetName === usingName) {
+      throw new Error(`merge(...) source name must differ from target source name: ${targetName}`)
+    }
     const onExpression = ctx.toDialectExpression(on)
     const matched = options.whenMatched
     const notMatched = options.whenNotMatched