effect-qb 0.12.3

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "effect-qb",
+  "version": "0.12.3",
+  "type": "module",
+  "files": [
+    "dist",
+    "src",
+    "README.md"
+  ],
+  "exports": {
+    "./postgres": {
+      "types": "./src/postgres.ts",
+      "import": "./dist/postgres.js"
+    },
+    "./mysql": {
+      "types": "./src/mysql.ts",
+      "import": "./dist/mysql.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "bun scripts/build-package.ts",
+    "test": "bun test",
+    "test:types": "bunx tsgo -p tsconfig.type-tests.json",
+    "test:integration": "bun scripts/test-integration.ts",
+    "prepack": "bun run build"
+  },
+  "devDependencies": {
+    "@effect/sql-mysql2": "0.48.0",
+    "@effect/sql-pg": "0.48.0",
+    "@types/bun": "latest",
+    "@typescript/native-preview": "latest"
+  },
+  "dependencies": {
+    "@effect/experimental": "^0.57.0",
+    "@effect/sql": "^0.48.0",
+    "effect": "^3.19.3"
+  }
+}

package/src/internal/aggregation-validation.ts

@@ -0,0 +1,57 @@
+import * as Expression from "./expression.js"
+import { groupingKeyOfExpression } from "./grouping-key.js"
+
+/** Recursive selection value accepted by aggregate-shape validation. */
+export type SelectionValue =
+  | Expression.Any
+  | {
+      readonly [key: string]: SelectionValue
+    }
+
+const isExpression = (value: unknown): value is Expression.Any =>
+  typeof value === "object" && value !== null && Expression.TypeId in value
+
+const selectionHasAggregate = (selection: SelectionValue): boolean => {
+  if (isExpression(selection)) {
+    return selection[Expression.TypeId].aggregation === "aggregate"
+  }
+  return Object.values(selection).some((value) => selectionHasAggregate(value))
+}
+
+const isGroupedSelectionValid = (
+  selection: SelectionValue,
+  groupedExpressions: ReadonlySet<string>
+): boolean => {
+  if (isExpression(selection)) {
+    const aggregation = selection[Expression.TypeId].aggregation
+    if (aggregation === "aggregate") {
+      return true
+    }
+    if (aggregation === "window") {
+      return false
+    }
+    if (Object.keys(selection[Expression.TypeId].dependencies).length === 0) {
+      return true
+    }
+    return groupedExpressions.has(groupingKeyOfExpression(selection))
+  }
+  return Object.values(selection).every((value) => isGroupedSelectionValid(value, groupedExpressions))
+}
+
+/**
+ * Validates that grouped/scalar selection mixing is legal for the provided
+ * `groupBy(...)` expressions.
+ */
+export const validateAggregationSelection = (
+  selection: SelectionValue,
+  grouped: readonly Expression.Any[]
+): void => {
+  const groupedExpressions = new Set(grouped.map(groupingKeyOfExpression))
+  const hasAggregate = selectionHasAggregate(selection)
+  const isValid = hasAggregate || grouped.length > 0
+    ? isGroupedSelectionValid(selection, groupedExpressions)
+    : true
+  if (!isValid) {
+    throw new Error("Invalid grouped selection: scalar expressions must be covered by groupBy(...) when aggregates are present")
+  }
+}

package/src/internal/case-analysis.ts

@@ -0,0 +1,50 @@
+import type * as Expression from "./expression.js"
+import type * as ExpressionAst from "./expression-ast.js"
+import type { PredicateFormula } from "./predicate-formula.js"
+import type { AssumeFormulaFalse, AssumeFormulaTrue, Contradicts, Implies } from "./predicate-analysis.js"
+import type { FormulaOfExpression } from "./predicate-normalize.js"
+
+export interface CasePath<
+  Assumptions extends PredicateFormula,
+  Value extends Expression.Any
+> {
+  readonly assumptions: Assumptions
+  readonly value: Value
+}
+
+type PredicateFormulaOf<Predicate extends Expression.Any> = FormulaOfExpression<Predicate>
+
+export type CaseBranchAssumeTrue<
+  Assumptions extends PredicateFormula,
+  Predicate extends Expression.Any
+> = AssumeFormulaTrue<Assumptions, PredicateFormulaOf<Predicate>>
+
+export type CaseBranchAssumeFalse<
+  Assumptions extends PredicateFormula,
+  Predicate extends Expression.Any
+> = AssumeFormulaFalse<Assumptions, PredicateFormulaOf<Predicate>>
+
+export type CaseBranchDecision<
+  Assumptions extends PredicateFormula,
+  Predicate extends Expression.Any
+> = Contradicts<Assumptions, Predicate> extends true
+  ? "skip"
+  : Implies<Assumptions, Predicate> extends true
+    ? "take"
+    : "branch"
+
+export type ReachableCasePaths<
+  Assumptions extends PredicateFormula,
+  Branches extends readonly ExpressionAst.CaseBranchNode[],
+  Else extends Expression.Any
+> = Branches extends readonly [
+  infer Head extends ExpressionAst.CaseBranchNode,
+  ...infer Tail extends readonly ExpressionAst.CaseBranchNode[]
+]
+  ? CaseBranchDecision<Assumptions, Head["when"]> extends "skip"
+    ? ReachableCasePaths<Assumptions, Tail, Else>
+    : CaseBranchDecision<Assumptions, Head["when"]> extends "take"
+      ? CasePath<CaseBranchAssumeTrue<Assumptions, Head["when"]>, Head["then"]>
+      : CasePath<CaseBranchAssumeTrue<Assumptions, Head["when"]>, Head["then"]> |
+        ReachableCasePaths<CaseBranchAssumeFalse<Assumptions, Head["when"]>, Tail, Else>
+  : CasePath<Assumptions, Else>

package/src/internal/coercion-analysis.ts

@@ -0,0 +1,30 @@
+import type * as Expression from "./expression.js"
+import type { CastTargetError, OperandCompatibilityError } from "./coercion-errors.js"
+import type { CanCastDbType, CanCompareDbTypes, CanTextuallyCoerceDbType } from "./coercion-rules.js"
+
+export type ComparableDbType<
+  Left extends Expression.DbType.Any,
+  Right extends Expression.DbType.Any,
+  Dialect extends string,
+  Operator extends string = "comparison"
+> = CanCompareDbTypes<Left, Right, Dialect> extends true
+  ? Right
+  : OperandCompatibilityError<Operator, Left, Right, Dialect, "the same db type family">
+
+export type TextCompatibleDbType<
+  Db extends Expression.DbType.Any,
+  Dialect extends string,
+  Operator extends string = "text operator"
+> = CanTextuallyCoerceDbType<Db, Dialect> extends true
+  ? Db
+  : OperandCompatibilityError<Operator, Db, Db, Dialect, "a text-compatible db type">
+
+export type CastableDbType<
+  Source extends Expression.DbType.Any,
+  Target extends Expression.DbType.Any,
+  Dialect extends string
+> = CanCastDbType<Source, Target, Dialect> extends true
+  ? Target
+  : CastTargetError<Source, Target, Dialect>
+
+export type RuntimeOfDbType<Db extends Expression.DbType.Any> = Expression.RuntimeOfDbType<Db>

package/src/internal/coercion-errors.ts

@@ -0,0 +1,29 @@
+import type * as Expression from "./expression.js"
+
+export type OperandCompatibilityError<
+  Operator extends string,
+  Left extends Expression.DbType.Any,
+  Right extends Expression.DbType.Any,
+  Dialect extends string,
+  Expected extends string
+> = {
+  readonly __effect_qb_error__: "effect-qb: incompatible operand types"
+  readonly __effect_qb_operator__: Operator
+  readonly __effect_qb_left_db_type__: Left
+  readonly __effect_qb_right_db_type__: Right
+  readonly __effect_qb_dialect__: Dialect
+  readonly __effect_qb_expected__: Expected
+  readonly __effect_qb_hint__: "Use cast(...) or pick values from the same db type family"
+}
+
+export type CastTargetError<
+  Source extends Expression.DbType.Any,
+  Target extends Expression.DbType.Any,
+  Dialect extends string
+> = {
+  readonly __effect_qb_error__: "effect-qb: unsupported cast target"
+  readonly __effect_qb_source_db_type__: Source
+  readonly __effect_qb_target_db_type__: Target
+  readonly __effect_qb_dialect__: Dialect
+  readonly __effect_qb_hint__: "Use one of the supported Q.type.<kind>() witnesses"
+}

package/src/internal/coercion-kind.ts

@@ -0,0 +1,32 @@
+import type * as Expression from "./expression.js"
+import type { FamilyOfDbType } from "./datatypes/lookup.js"
+
+export type CoercionKind =
+  | "text"
+  | "numeric"
+  | "boolean"
+  | "date"
+  | "time"
+  | "timestamp"
+  | "binary"
+  | "interval"
+  | "uuid"
+  | "json"
+  | "xml"
+  | "bit"
+  | "identifier"
+  | "network"
+  | "spatial"
+  | "textsearch"
+  | "range"
+  | "multirange"
+  | "array"
+  | "record"
+  | "domain"
+  | "enum"
+  | "set"
+  | "money"
+  | "null"
+  | `other:${string}`
+
+export type CoercionKindOf<Db extends Expression.DbType.Any> = FamilyOfDbType<Db>

package/src/internal/coercion-normalize.ts

@@ -0,0 +1,7 @@
+import type * as Expression from "./expression.js"
+
+/** Extracts the database type carried by an expression. */
+export type DbTypeOfExpression<Value extends Expression.Any> = Expression.DbTypeOf<Value>
+
+/** Extracts the decoded runtime type carried by an expression. */
+export type RuntimeOfExpression<Value extends Expression.Any> = Expression.RuntimeOf<Value>

package/src/internal/coercion-rules.ts

@@ -0,0 +1,25 @@
+import type * as Expression from "./expression.js"
+import type { CanCastDbType as LookupCanCastDbType, CanCompareDbTypes as LookupCanCompareDbTypes, CanContainDbTypes as LookupCanContainDbTypes, CanTextuallyCoerceDbType as LookupCanTextuallyCoerceDbType } from "./datatypes/lookup.js"
+
+export type CanCompareDbTypes<
+  Left extends Expression.DbType.Any,
+  Right extends Expression.DbType.Any,
+  Dialect extends string
+> = LookupCanCompareDbTypes<Left, Right, Dialect>
+
+export type CanContainDbTypes<
+  Left extends Expression.DbType.Any,
+  Right extends Expression.DbType.Any,
+  Dialect extends string
+> = LookupCanContainDbTypes<Left, Right, Dialect>
+
+export type CanTextuallyCoerceDbType<
+  Db extends Expression.DbType.Any,
+  Dialect extends string
+> = LookupCanTextuallyCoerceDbType<Db, Dialect>
+
+export type CanCastDbType<
+  Source extends Expression.DbType.Any,
+  Target extends Expression.DbType.Any,
+  Dialect extends string
+> = LookupCanCastDbType<Source, Target, Dialect>