effect-qb 0.13.0 → 0.15.0

package/src/internal/expression.ts

@@ -1,327 +0,0 @@
-import type { Pipeable } from "effect/Pipeable"
-import type * as Schema from "effect/Schema"
-import type { RuntimeOfDbType as RuntimeOfDbTypeLookup } from "./datatypes/lookup.js"
-
-export type {
-  BigIntString,
-  DecimalString,
-  InstantString,
-  JsonPrimitive,
-  JsonValue,
-  LocalDateString,
-  LocalDateTimeString,
-  LocalTimeString,
-  OffsetTimeString,
-  YearString
-} from "./runtime-value.js"
-
-/** Symbol used to attach expression metadata to runtime values. */
-export const TypeId: unique symbol = Symbol.for("effect-qb/Expression")
-
-export type TypeId = typeof TypeId
-
-/**
- * Bound source provenance for a column-like expression.
- *
- * `tableName` is the logical source identity currently visible to the query
- * layer. For aliased sources this is the alias, while `baseTableName` retains
- * the underlying physical table name for downstream renderer work.
- */
-export interface ColumnSource<
-  TableName extends string = string,
-  ColumnName extends string = string,
-  BaseTableName extends string = TableName
-> {
-  readonly tableName: TableName
-  readonly columnName: ColumnName
-  readonly baseTableName: BaseTableName
-}
-
-/**
- * Three-state nullability lattice.
- *
- * `"never"` means non-null, `"maybe"` means nullable, and `"always"` means the
- * expression is known to be `null`.
- */
-export type Nullability = "never" | "maybe" | "always"
-
-/**
- * High-level classification of an expression.
- *
- * - `scalar`: regular per-row expression
- * - `aggregate`: grouped expression such as `count(*)`
- * - `window`: windowed expression such as `row_number() over (...)`
- */
-export type AggregationKind = "scalar" | "aggregate" | "window"
-
-/**
- * Whether an expression should still be promoted by optional-source scope.
- *
- * Most expressions propagate optional-source nullability because a missing
- * joined row turns their inputs into `null`. Some expressions, such as
- * `coalesce(...)`, `is null`, and aggregates, already model their own
- * null-handling semantics and should not be promoted again by plan scope.
- */
-export type SourceNullabilityMode = "propagate" | "resolved"
-
-/**
- * Phantom dependency map of source names referenced by an expression.
- *
- * This is intentionally separate from runtime provenance (`source`). The
- * dependency map is the cheap, composable type-level representation used by the
- * query layer to resolve scope-sensitive nullability after joins. Dependencies
- * are tracked by logical source identity, which means aliased sources are kept
- * distinct from one another even when they point at the same base table.
- */
-export type SourceDependencies = Record<string, true>
-
-/** Database-type descriptors carried alongside decoded runtime types. */
-export declare namespace DbType {
-  /** Base SQL type descriptor. */
-  export interface Base<Dialect extends string, Kind extends string> {
-    readonly dialect: Dialect
-    readonly kind: Kind
-  }
-
-  /** JSON-like database type. */
-  export interface Json<
-    Dialect extends string = "postgres",
-    SchemaName extends string = "json"
-  > extends Base<Dialect, SchemaName>
-  {
-    readonly variant: "json"
-  }
-
-  /** Array database type. */
-  export interface Array<
-    Dialect extends string = string,
-    Element extends Any = any,
-    Kind extends string = string
-  > extends Base<Dialect, Kind> {
-    readonly element: Element
-  }
-
-  /** Range database type. */
-  export interface Range<
-    Dialect extends string = string,
-    Subtype extends Any = any,
-    Kind extends string = string
-  > extends Base<Dialect, Kind> {
-    readonly subtype: Subtype
-  }
-
-  /** Multirange database type. */
-  export interface Multirange<
-    Dialect extends string = string,
-    Subtype extends Any = any,
-    Kind extends string = string
-  > extends Base<Dialect, Kind> {
-    readonly subtype: Subtype
-  }
-
-  /** Composite/record database type. */
-  export interface Composite<
-    Dialect extends string = string,
-    Fields extends Record<string, Any> = Record<string, any>,
-    Kind extends string = string
-  > extends Base<Dialect, Kind> {
-    readonly fields: Fields
-  }
-
-  /** Named domain database type. */
-  export interface Domain<
-    Dialect extends string = string,
-    BaseType extends Any = any,
-    Kind extends string = string
-  > extends Base<Dialect, Kind> {
-    readonly base: BaseType
-  }
-
-  /** Enumeration database type. */
-  export interface Enum<
-    Dialect extends string = string,
-    Kind extends string = string
-  > extends Base<Dialect, Kind> {
-    readonly variant: "enum"
-  }
-
-  /** Set database type. */
-  export interface Set<
-    Dialect extends string = string,
-    Kind extends string = string
-  > extends Base<Dialect, Kind> {
-    readonly variant: "set"
-  }
-
-  export type PgUuid = Base<"postgres", "uuid">
-  export type PgText = Base<"postgres", "text">
-  export type PgVarchar = Base<"postgres", "varchar">
-  export type PgChar = Base<"postgres", "char">
-  export type PgCitext = Base<"postgres", "citext">
-  export type PgInt2 = Base<"postgres", "int2">
-  export type PgInt4 = Base<"postgres", "int4">
-  export type PgInt8 = Base<"postgres", "int8">
-  export type PgNumeric = Base<"postgres", "numeric">
-  export type PgFloat4 = Base<"postgres", "float4">
-  export type PgFloat8 = Base<"postgres", "float8">
-  export type PgBool = Base<"postgres", "bool">
-  export type PgDate = Base<"postgres", "date">
-  export type PgTime = Base<"postgres", "time">
-  export type PgTimestamp = Base<"postgres", "timestamp">
-  export type PgTimetz = Base<"postgres", "timetz">
-  export type PgTimestamptz = Base<"postgres", "timestamptz">
-  export type PgInterval = Base<"postgres", "interval">
-  export type PgBytea = Base<"postgres", "bytea">
-  export type PgJsonb = Base<"postgres", "jsonb">
-  export type PgArray<Element extends Any = any> = Array<"postgres", Element, string>
-  export type PgRange<Subtype extends Any = any, Kind extends string = string> = Range<"postgres", Subtype, Kind>
-  export type PgMultirange<Subtype extends Any = any, Kind extends string = string> = Multirange<"postgres", Subtype, Kind>
-  export type PgComposite<Fields extends Record<string, Any> = Record<string, any>, Kind extends string = string> = Composite<"postgres", Fields, Kind>
-  export type PgDomain<BaseType extends Any = any, Kind extends string = string> = Domain<"postgres", BaseType, Kind>
-
-  export type MySqlUuid = Base<"mysql", "uuid">
-  export type MySqlText = Base<"mysql", "text">
-  export type MySqlVarchar = Base<"mysql", "varchar">
-  export type MySqlChar = Base<"mysql", "char">
-  export type MySqlTinyInt = Base<"mysql", "tinyint">
-  export type MySqlSmallInt = Base<"mysql", "smallint">
-  export type MySqlMediumInt = Base<"mysql", "mediumint">
-  export type MySqlInt = Base<"mysql", "int">
-  export type MySqlBigInt = Base<"mysql", "bigint">
-  export type MySqlNumeric = Base<"mysql", "decimal">
-  export type MySqlFloat = Base<"mysql", "float">
-  export type MySqlDouble = Base<"mysql", "double">
-  export type MySqlBool = Base<"mysql", "boolean">
-  export type MySqlDate = Base<"mysql", "date">
-  export type MySqlTime = Base<"mysql", "time">
-  export type MySqlDatetime = Base<"mysql", "datetime">
-  export type MySqlTimestamp = Base<"mysql", "timestamp">
-  export type MySqlBinary = Base<"mysql", "binary">
-  export type MySqlVarBinary = Base<"mysql", "varbinary">
-  export type MySqlBlob = Base<"mysql", "blob">
-  export type MySqlArray<Element extends Any = any> = Array<"mysql", Element, string>
-  export type MySqlComposite<Fields extends Record<string, Any> = Record<string, any>, Kind extends string = string> = Composite<"mysql", Fields, Kind>
-  export type MySqlDomain<BaseType extends Any = any, Kind extends string = string> = Domain<"mysql", BaseType, Kind>
-
-  export type Any =
-    | PgUuid
-    | PgText
-    | PgVarchar
-    | PgChar
-    | PgCitext
-    | PgInt2
-    | PgInt4
-    | PgInt8
-    | PgNumeric
-    | PgFloat4
-    | PgFloat8
-    | PgBool
-    | PgDate
-    | PgTime
-    | PgTimestamp
-    | PgInterval
-    | PgBytea
-    | PgJsonb
-    | PgArray
-    | PgRange
-    | PgMultirange
-    | PgComposite
-    | PgDomain
-    | MySqlUuid
-    | MySqlText
-    | MySqlVarchar
-    | MySqlChar
-    | MySqlTinyInt
-    | MySqlSmallInt
-    | MySqlMediumInt
-    | MySqlInt
-    | MySqlBigInt
-    | MySqlNumeric
-    | MySqlFloat
-    | MySqlDouble
-    | MySqlBool
-    | MySqlDate
-    | MySqlTime
-    | MySqlDatetime
-    | MySqlTimestamp
-    | MySqlBinary
-    | MySqlVarBinary
-    | MySqlBlob
-    | MySqlArray
-    | MySqlComposite
-    | MySqlDomain
-    | Json
-    | Base<string, string>
-    | Array<string, any, string>
-    | Range<string, any, string>
-    | Multirange<string, any, string>
-    | Composite<string, Record<string, any>, string>
-    | Domain<string, any, string>
-    | Enum<string, string>
-    | Set<string, string>
-  }
-
-/** Canonical static metadata stored on an expression. */
-export interface State<
-  Runtime,
-  Db extends DbType.Any,
-  Nullable extends Nullability,
-  Dialect extends string,
-  Aggregation extends AggregationKind,
-  Source = never,
-  Dependencies extends SourceDependencies = {},
-  SourceNullability extends SourceNullabilityMode = "propagate"
-> {
-  readonly runtime: Runtime
-  readonly dbType: Db
-  readonly runtimeSchema?: Schema.Schema.Any
-  readonly nullability: Nullable
-  readonly dialect: Dialect
-  readonly aggregation: Aggregation
-  readonly source: Source
-  readonly sourceNullability: SourceNullability
-  /**
-   * Type-level source dependency map used for lazy nullability resolution.
-   *
-   * Unlike `source`, which preserves runtime provenance detail for diagnostics
-   * and plan assembly, `dependencies` only needs to record which tables are
-   * referenced at all.
-   */
-  readonly dependencies: Dependencies
-}
-
-/**
- * A typed SQL expression.
- *
- * `Runtime` is the decoded TypeScript type while `Db` captures the SQL-level
- * type identity. Both are needed: multiple SQL types may decode to the same
- * runtime type but still have different comparison/cast semantics.
- */
-export interface Expression<
-  Runtime,
-  Db extends DbType.Any,
-  Nullable extends Nullability = "never",
-  Dialect extends string = Db["dialect"],
-  Aggregation extends AggregationKind = "scalar",
-  Source = never,
-  Dependencies extends SourceDependencies = {},
-  SourceNullability extends SourceNullabilityMode = "propagate"
-> extends Pipeable {
-  readonly [TypeId]: State<Runtime, Db, Nullable, Dialect, Aggregation, Source, Dependencies, SourceNullability>
-}
-
-/** Convenience alias for any expression-like value. */
-export type Any = Expression<any, DbType.Any, Nullability, string, AggregationKind, any, SourceDependencies, SourceNullabilityMode>
-/** Extracts an expression's decoded runtime type. */
-export type RuntimeOf<Value extends Any> = Value[typeof TypeId]["runtime"]
-/** Extracts an expression's database-type descriptor. */
-export type DbTypeOf<Value extends Any> = Value[typeof TypeId]["dbType"]
-/** Extracts an expression's nullability state. */
-export type NullabilityOf<Value extends Any> = Value[typeof TypeId]["nullability"]
-/** Extracts an expression's source dependency map. */
-export type DependenciesOf<Value extends Any> = Value[typeof TypeId]["dependencies"]
-/** Extracts how plan-scope nullability should apply to an expression. */
-export type SourceNullabilityOf<Value extends Any> = Value[typeof TypeId]["sourceNullability"]
-
-/** Maps a database type descriptor back to its decoded runtime type. */
-export type RuntimeOfDbType<Db extends DbType.Any> = RuntimeOfDbTypeLookup<Db>

package/src/internal/predicate-normalize.ts

@@ -1,202 +0,0 @@
-import type * as Expression from "./expression.js"
-import type * as ExpressionAst from "./expression-ast.js"
-import type { ColumnKeyOfExpression, ValueKey } from "./predicate-key.js"
-import type { AllFormula, AnyFormula, AtomFormula, FalseFormula, NotFormula, PredicateFormula, TrueFormula } from "./predicate-formula.js"
-import type { EqColumnAtom, EqLiteralAtom, NeqLiteralAtom, NonNullAtom, NullAtom, UnknownAtom } from "./predicate-atom.js"
-
-type AstOf<Value extends Expression.Any> = Value extends {
-  readonly [ExpressionAst.TypeId]: infer Ast extends ExpressionAst.Any
-} ? Ast : never
-
-type LiteralValueOfExpression<Value extends Expression.Any> = AstOf<Value> extends ExpressionAst.LiteralNode<infer Literal>
-  ? Literal
-  : never
-
-type True = TrueFormula
-type False = FalseFormula
-
-type UnknownTag<Tag extends string> = AtomFormula<UnknownAtom<Tag>>
-type AtomOf<Atom extends import("./predicate-atom.js").PredicateAtom> = AtomFormula<Atom>
-type FactOf<Atom extends import("./predicate-atom.js").PredicateAtom> = AtomFormula<Atom>
-
-type NonNullFactsOfExpression<Value extends Expression.Any> =
-  [ColumnKeyOfExpression<Value>] extends [never]
-    ? never
-    : FactOf<NonNullAtom<ColumnKeyOfExpression<Value>>>
-
-type CombineFacts<
-  Left extends PredicateFormula,
-  Right extends PredicateFormula
-> = [Left] extends [never]
-  ? Right
-  : [Right] extends [never]
-    ? Left
-    : import("./predicate-formula.js").NormalizeBooleanConstants<AllFormula<[Left, Right]>>
-
-type FactsOfExpressions<Values extends readonly Expression.Any[]> =
-  Values extends readonly [
-    infer Head extends Expression.Any,
-    ...infer Tail extends readonly Expression.Any[]
-  ]
-    ? CombineFacts<FormulaOfExpression<Head>, FactsOfExpressions<Tail>>
-    : never
-
-type FormulaOfEq<
-  Left extends Expression.Any,
-  Right extends Expression.Any
-> =
-  [ColumnKeyOfExpression<Left>] extends [never]
-    ? [ColumnKeyOfExpression<Right>] extends [never]
-      ? LiteralValueOfExpression<Left> extends infer LeftLiteral
-        ? LiteralValueOfExpression<Right> extends infer RightLiteral
-          ? [LeftLiteral] extends [never]
-            ? UnknownTag<"eq:unsupported">
-            : [RightLiteral] extends [never]
-              ? UnknownTag<"eq:unsupported">
-              : LeftLiteral extends null
-                ? False
-                : RightLiteral extends null
-                  ? False
-              : [LeftLiteral] extends [RightLiteral]
-                ? True
-                : False
-          : UnknownTag<"eq:unsupported">
-        : UnknownTag<"eq:unsupported">
-      : LiteralValueOfExpression<Left> extends infer LeftLiteral
-        ? [LeftLiteral] extends [never]
-          ? UnknownTag<"eq:unsupported">
-          : LeftLiteral extends null
-            ? False
-            : AtomOf<EqLiteralAtom<ColumnKeyOfExpression<Right>, ValueKey<LeftLiteral>>>
-        : UnknownTag<"eq:unsupported">
-    : [ColumnKeyOfExpression<Right>] extends [never]
-      ? LiteralValueOfExpression<Right> extends infer RightLiteral
-        ? [RightLiteral] extends [never]
-          ? UnknownTag<"eq:unsupported">
-          : RightLiteral extends null
-            ? False
-            : AtomOf<EqLiteralAtom<ColumnKeyOfExpression<Left>, ValueKey<RightLiteral>>>
-        : UnknownTag<"eq:unsupported">
-      : AtomOf<import("./predicate-atom.js").EqColumnAtom<ColumnKeyOfExpression<Left>, ColumnKeyOfExpression<Right>>>
-
-type FormulaOfVariadic<
-  Kind extends ExpressionAst.VariadicKind,
-  Values extends readonly Expression.Any[]
-> = Kind extends "and"
-  ? import("./predicate-formula.js").NormalizeBooleanConstants<import("./predicate-formula.js").AllFormula<{
-      readonly [K in keyof Values]: Values[K] extends Expression.Any ? FormulaOfExpression<Values[K]> : never
-    } & readonly PredicateFormula[]>>
-  : Kind extends "or"
-    ? import("./predicate-formula.js").NormalizeBooleanConstants<import("./predicate-formula.js").AnyFormula<{
-        readonly [K in keyof Values]: Values[K] extends Expression.Any ? FormulaOfExpression<Values[K]> : never
-      } & readonly PredicateFormula[]>>
-    : Kind extends "in" | "notIn" | "between"
-      ? FactsOfExpressions<Values> extends infer Facts extends PredicateFormula
-        ? [Facts] extends [never]
-          ? UnknownTag<`variadic:${Kind}`>
-          : Facts
-        : UnknownTag<`variadic:${Kind}`>
-    : UnknownTag<`variadic:${Kind}`>
-
-export type FormulaOfExpression<Value extends Expression.Any> =
-  AstOf<Value> extends infer Ast extends ExpressionAst.Any
-    ? Ast extends ExpressionAst.LiteralNode<infer Literal>
-      ? Literal extends true
-        ? True
-        : Literal extends false
-          ? False
-          : UnknownTag<"literal:non-boolean">
-      : Ast extends ExpressionAst.UnaryNode<infer Kind extends ExpressionAst.UnaryKind, infer Inner extends Expression.Any>
-        ? Kind extends "isNull"
-    ? [ColumnKeyOfExpression<Inner>] extends [never]
-            ? UnknownTag<"isNull:unsupported">
-            : AtomOf<NullAtom<ColumnKeyOfExpression<Inner>>>
-          : Kind extends "isNotNull"
-            ? [ColumnKeyOfExpression<Inner>] extends [never]
-              ? UnknownTag<"isNotNull:unsupported">
-              : AtomOf<NonNullAtom<ColumnKeyOfExpression<Inner>>>
-            : Kind extends "not"
-              ? import("./predicate-formula.js").Not<FormulaOfExpression<Inner>>
-              : UnknownTag<`unary:${Kind}`>
-        : Ast extends ExpressionAst.BinaryNode<"eq", infer Left extends Expression.Any, infer Right extends Expression.Any>
-          ? FormulaOfEq<Left, Right>
-          : Ast extends ExpressionAst.BinaryNode<"neq", infer Left extends Expression.Any, infer Right extends Expression.Any>
-            ? Left extends Expression.Any
-              ? Right extends Expression.Any
-                ? [ColumnKeyOfExpression<Left>] extends [never]
-                  ? [ColumnKeyOfExpression<Right>] extends [never]
-                    ? LiteralValueOfExpression<Left> extends infer LeftLiteral
-                      ? LiteralValueOfExpression<Right> extends infer RightLiteral
-                        ? [LeftLiteral] extends [never]
-                          ? UnknownTag<"neq:unsupported">
-                          : [RightLiteral] extends [never]
-                            ? UnknownTag<"neq:unsupported">
-                            : LeftLiteral extends null
-                              ? False
-                              : RightLiteral extends null
-                                ? False
-                                : [LeftLiteral] extends [RightLiteral]
-                                  ? False
-                                  : True
-                        : UnknownTag<"neq:unsupported">
-                      : UnknownTag<"neq:unsupported">
-                    : CombineFacts<NonNullFactsOfExpression<Left>, NonNullFactsOfExpression<Right>>
-                  : CombineFacts<NonNullFactsOfExpression<Left>, NonNullFactsOfExpression<Right>>
-                : UnknownTag<"neq:unsupported">
-              : UnknownTag<"neq:unsupported">
-            : Ast extends ExpressionAst.BinaryNode<infer Kind extends "lt" | "lte" | "gt" | "gte" | "like" | "ilike" | "isDistinctFrom" | "isNotDistinctFrom" | "contains" | "containedBy" | "overlaps", infer Left extends Expression.Any, infer Right extends Expression.Any>
-              ? Kind extends "isNotDistinctFrom"
-                ? Left extends Expression.Any
-                  ? Right extends Expression.Any
-                    ? LiteralValueOfExpression<Left> extends infer LeftLiteral
-                      ? LiteralValueOfExpression<Right> extends infer RightLiteral
-                        ? [LeftLiteral] extends [never]
-                          ? [RightLiteral] extends [never]
-                            ? UnknownTag<"isNotDistinctFrom:unsupported">
-                            : RightLiteral extends null
-                              ? [ColumnKeyOfExpression<Left>] extends [never]
-                                ? UnknownTag<"isNotDistinctFrom:unsupported">
-                                : AtomOf<NullAtom<ColumnKeyOfExpression<Left>>>
-                              : UnknownTag<"isNotDistinctFrom:unsupported">
-                          : LeftLiteral extends null
-                            ? [ColumnKeyOfExpression<Right>] extends [never]
-                              ? UnknownTag<"isNotDistinctFrom:unsupported">
-                              : AtomOf<NullAtom<ColumnKeyOfExpression<Right>>>
-                            : RightLiteral extends null
-                              ? [ColumnKeyOfExpression<Left>] extends [never]
-                                ? UnknownTag<"isNotDistinctFrom:unsupported">
-                                : AtomOf<NullAtom<ColumnKeyOfExpression<Left>>>
-                              : [ColumnKeyOfExpression<Left>] extends [never]
-                                ? [ColumnKeyOfExpression<Right>] extends [never]
-                                  ? CombineFacts<NonNullFactsOfExpression<Left>, NonNullFactsOfExpression<Right>>
-                                  : AtomOf<EqLiteralAtom<ColumnKeyOfExpression<Right>, ValueKey<LeftLiteral>>>
-                                : AtomOf<EqLiteralAtom<ColumnKeyOfExpression<Left>, ValueKey<RightLiteral>>>
-                        : UnknownTag<"isNotDistinctFrom:unsupported">
-                      : UnknownTag<"isNotDistinctFrom:unsupported">
-                    : UnknownTag<"isNotDistinctFrom:unsupported">
-                  : UnknownTag<"isNotDistinctFrom:unsupported">
-                : Kind extends "isDistinctFrom"
-                  ? UnknownTag<"isDistinctFrom:unsupported">
-                  : CombineFacts<NonNullFactsOfExpression<Left>, NonNullFactsOfExpression<Right>>
-              : Ast extends ExpressionAst.VariadicNode<"and", infer Values extends readonly Expression.Any[]>
-                ? import("./predicate-formula.js").NormalizeBooleanConstants<import("./predicate-formula.js").AllFormula<{
-                    readonly [K in keyof Values]: Values[K] extends Expression.Any ? FormulaOfExpression<Values[K]> : never
-                  } & readonly PredicateFormula[]>>
-                : Ast extends ExpressionAst.VariadicNode<"or", infer Values extends readonly Expression.Any[]>
-                  ? import("./predicate-formula.js").NormalizeBooleanConstants<import("./predicate-formula.js").AnyFormula<{
-                      readonly [K in keyof Values]: Values[K] extends Expression.Any ? FormulaOfExpression<Values[K]> : never
-                    } & readonly PredicateFormula[]>>
-                  : Ast extends ExpressionAst.VariadicNode<infer Kind extends "in" | "notIn" | "between", infer Values extends readonly Expression.Any[]>
-                    ? CombineFacts<NonNullFactsOfExpression<Values[number]>, UnknownTag<`variadic:${Kind}`>>
-                    : Ast extends ExpressionAst.BinaryNode<infer Kind extends ExpressionAst.BinaryKind, infer Left extends Expression.Any, infer Right extends Expression.Any>
-                      ? Kind extends "eq"
-                        ? FormulaOfEq<Left, Right>
-                        : CombineFacts<NonNullFactsOfExpression<Left>, NonNullFactsOfExpression<Right>>
-                      : UnknownTag<`expr:${Ast["kind"]}`>
-    : UnknownTag<"missing-ast">
-
-export type FormulaOfPredicate<Value> =
-  Value extends true ? True :
-    Value extends false ? False :
-      Value extends Expression.Any ? FormulaOfExpression<Value> :
-        UnknownTag<"predicate:unsupported">

package/src/mysql/function/json.ts

@@ -1,4 +0,0 @@
-import { mysqlQuery } from "../private/query.js"
-
-/** MySQL JSON expression helpers. */
-export const json = mysqlQuery.json

package/src/mysql/private/query.ts

@@ -1,13 +0,0 @@
-import * as Expression from "../../internal/expression.js"
-import { makeDialectQuery } from "../../internal/query-factory.js"
-import { mysqlDatatypes } from "../datatypes/index.js"
-
-export const mysqlQuery = makeDialectQuery({
-  dialect: "mysql",
-  textDb: { dialect: "mysql", kind: "text" } as Expression.DbType.MySqlText,
-  numericDb: { dialect: "mysql", kind: "double" } as Expression.DbType.MySqlDouble,
-  boolDb: { dialect: "mysql", kind: "boolean" } as Expression.DbType.MySqlBool,
-  timestampDb: { dialect: "mysql", kind: "timestamp" } as Expression.DbType.MySqlTimestamp,
-  nullDb: { dialect: "mysql", kind: "null" } as Expression.DbType.Base<"mysql", "null">,
-  type: mysqlDatatypes
-})

package/src/postgres/function/json.ts

@@ -1,4 +0,0 @@
-import { postgresQuery } from "../private/query.js"
-
-/** Postgres JSON expression helpers. */
-export const json = postgresQuery.json

package/src/postgres/private/query.ts

@@ -1,13 +0,0 @@
-import * as Expression from "../../internal/expression.js"
-import { makeDialectQuery } from "../../internal/query-factory.js"
-import { postgresDatatypes } from "../datatypes/index.js"
-
-export const postgresQuery = makeDialectQuery({
-  dialect: "postgres",
-  textDb: { dialect: "postgres", kind: "text" } as Expression.DbType.PgText,
-  numericDb: { dialect: "postgres", kind: "float8" } as Expression.DbType.PgFloat8,
-  boolDb: { dialect: "postgres", kind: "bool" } as Expression.DbType.PgBool,
-  timestampDb: { dialect: "postgres", kind: "timestamp" } as Expression.DbType.PgTimestamp,
-  nullDb: { dialect: "postgres", kind: "null" } as Expression.DbType.Base<"postgres", "null">,
-  type: postgresDatatypes
-})