effect-qb 0.12.3 → 0.14.0

package/src/mysql/query.ts

@@ -1,5 +1,3 @@
-import * as Expression from "../internal/expression.js"
-import { mysqlDatatypes } from "./datatypes/index.js"
 import {
   type CapabilitiesOfPlan,
   type CompletePlan,
@@ -37,22 +35,12 @@ import {
   type StatementOfPlan,
   type StringExpressionInput
 } from "../internal/query.js"
-import { makeDialectQuery } from "../internal/query-factory.js"
-
-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
-})
+import { mysqlQuery } from "./private/query.js"
 
 export const literal = mysqlQuery.literal
+export const column = mysqlQuery.column
 export const cast = mysqlQuery.cast
 export const type = mysqlQuery.type
-export const json = mysqlQuery.json
 export const eq = mysqlQuery.eq
 export const neq = mysqlQuery.neq
 export const lt = mysqlQuery.lt
@@ -61,10 +49,12 @@ export const gt = mysqlQuery.gt
 export const gte = mysqlQuery.gte
 export const isNull = mysqlQuery.isNull
 export const isNotNull = mysqlQuery.isNotNull
-export const upper = mysqlQuery.upper
-export const lower = mysqlQuery.lower
 export const like = mysqlQuery.like
 export const ilike = mysqlQuery.ilike
+export const regexMatch = mysqlQuery.regexMatch
+export const regexIMatch = mysqlQuery.regexIMatch
+export const regexNotMatch = mysqlQuery.regexNotMatch
+export const regexNotIMatch = mysqlQuery.regexNotIMatch
 export const and = mysqlQuery.and
 export const or = mysqlQuery.or
 export const not = mysqlQuery.not
@@ -72,22 +62,13 @@ export const all = mysqlQuery.all
 export const any = mysqlQuery.any
 const case_ = mysqlQuery.case
 export const match = mysqlQuery.match
-export const coalesce = mysqlQuery.coalesce
 export const in_ = mysqlQuery.in
 export const notIn = mysqlQuery.notIn
 export const between = mysqlQuery.between
 export const contains = mysqlQuery.contains
 export const containedBy = mysqlQuery.containedBy
 export const overlaps = mysqlQuery.overlaps
-export const concat = mysqlQuery.concat
 export const exists = mysqlQuery.exists
-export const over = mysqlQuery.over
-export const rowNumber = mysqlQuery.rowNumber
-export const rank = mysqlQuery.rank
-export const denseRank = mysqlQuery.denseRank
-export const count = mysqlQuery.count
-export const max = mysqlQuery.max
-export const min = mysqlQuery.min
 export const isDistinctFrom = mysqlQuery.isDistinctFrom
 export const isNotDistinctFrom = mysqlQuery.isNotDistinctFrom
 export const excluded = mysqlQuery.excluded
@@ -103,7 +84,6 @@ export const values = mysqlQuery.values
 export const unnest = mysqlQuery.unnest
 export const generateSeries = mysqlQuery.generateSeries
 export const returning = mysqlQuery.returning
-export const defaultValues = mysqlQuery.defaultValues
 export const onConflict = mysqlQuery.onConflict
 export const insert = mysqlQuery.insert
 export const update = mysqlQuery.update

package/src/mysql.ts

@@ -6,6 +6,8 @@ export * as Datatypes from "./mysql/datatypes/index.js"
 export * as Errors from "./mysql/errors/index.js"
 /** Shared scalar SQL expression interfaces and DB-type descriptors. */
 export * as Expression from "./internal/expression.js"
+/** MySQL-specialized SQL function expressions. */
+export * as Function from "./mysql/function/index.js"
 /** MySQL-specialized typed query execution contracts. */
 export * as Executor from "./mysql/executor.js"
 /** Shared logical query-plan interfaces. */

package/src/postgres/cast.ts

@@ -0,0 +1,31 @@
+import type * as Expression from "../internal/expression.js"
+import { postgresQuery } from "./private/query.js"
+
+type CastInput = Parameters<typeof postgresQuery.cast>[0]
+type CastTarget = Parameters<typeof postgresQuery.cast>[1]
+type CastExpression<Target extends CastTarget> = Expression.Expression<
+  Expression.RuntimeOfDbType<Target>,
+  Target,
+  Expression.Nullability,
+  string,
+  Expression.AggregationKind,
+  any,
+  Expression.SourceDependencies,
+  Expression.SourceNullabilityMode
+>
+
+const to: {
+  <Value extends CastInput, Target extends CastTarget>(
+    value: Value,
+    target: Target
+  ): CastExpression<Target>
+  <Target extends CastTarget>(
+    target: Target
+  ): <Value extends CastInput>(value: Value) => CastExpression<Target>
+} = ((...args: [CastInput, CastTarget] | [CastTarget]) =>
+  args.length === 1
+    ? ((value: CastInput) => postgresQuery.cast(value as never, args[0] as never))
+    : postgresQuery.cast(args[0] as never, args[1] as never)) as unknown as typeof to
+
+/** Postgres cast helpers. */
+export const cast = { to }

package/src/postgres/column.ts

@@ -1,11 +1,37 @@
 export {
+  brand,
+  ddlType,
+  int2,
   boolean,
   date,
+  default_ as default,
+  int8,
+  float4,
+  float8,
   generated,
-  hasDefault,
+  array,
+  identityAlways,
+  identityByDefault,
+  foreignKey,
+  index,
   int,
+  char,
+  varchar,
   json,
+  jsonb,
   nullable,
+  time,
+  timetz,
+  timestamptz,
+  interval,
+  bytea,
+  name,
+  oid,
+  regclass,
+  bit,
+  varbit,
+  xml,
+  pg_lsn,
   number,
   primaryKey,
   references,

package/src/postgres/datatypes/index.ts

@@ -1,8 +1,43 @@
-import { makeDatatypeModule } from "../../internal/datatypes/define.js"
-import { postgresDatatypeKinds } from "./spec.js"
+import type { DatatypeModule } from "../../internal/datatypes/define.js"
+import type * as Expression from "../../internal/expression.js"
+import { postgresDatatypeFamilies, postgresDatatypeKinds } from "./spec.js"
 
-export const postgresDatatypes = makeDatatypeModule("postgres", postgresDatatypeKinds, {
-  boolean: "bool"
-})
+const postgresDatatypeModule = {
+  custom: (kind: string) => ({
+    dialect: "postgres",
+    kind
+  }),
+  boolean: () => ({
+    dialect: "postgres",
+    kind: "bool"
+  })
+} as Record<string, (...args: readonly any[]) => Expression.DbType.Base<"postgres", string>>
+
+for (const kind of Object.keys(postgresDatatypeKinds)) {
+  postgresDatatypeModule[kind] = () => ({
+    dialect: "postgres",
+    kind
+  })
+}
+
+export const postgresDatatypes = {
+  ...(postgresDatatypeModule as DatatypeModule<
+    "postgres",
+    typeof postgresDatatypeKinds,
+    { readonly boolean: "bool" }
+  >),
+  json: (): Expression.DbType.Json<"postgres", "json"> => ({
+    dialect: "postgres",
+    kind: "json",
+    variant: "json"
+  }),
+  jsonb: (): Expression.DbType.Json<"postgres", "jsonb"> => ({
+    dialect: "postgres",
+    kind: "jsonb",
+    variant: "jsonb"
+  })
+}
+
+export { postgresDatatypeFamilies, postgresDatatypeKinds }
 
 export type PostgresDatatypeModule = typeof postgresDatatypes

package/src/postgres/executor.ts

@@ -2,8 +2,8 @@ import * as Effect from "effect/Effect"
 import * as SqlClient from "@effect/sql/SqlClient"
 
 import * as CoreExecutor from "../internal/executor.js"
-import * as Query from "./query.js"
-import * as Renderer from "./renderer.js"
+import * as CoreQuery from "../internal/query.js"
+import * as CoreRenderer from "../internal/renderer.js"
 import {
   narrowPostgresDriverErrorForReadQuery,
   normalizePostgresDriverError,
@@ -19,17 +19,19 @@ export type RowDecodeError = CoreExecutor.RowDecodeError
 export type Driver<Error = never, Context = never> = CoreExecutor.Driver<"postgres", Error, Context>
 /** Postgres-specialized executor contract. */
 export type Executor<Error = never, Context = never> = CoreExecutor.Executor<"postgres", Error, Context>
+/** Postgres-specialized renderer contract. */
+export type Renderer = CoreRenderer.Renderer<"postgres">
 /** Optional renderer / driver overrides for the standard Postgres executor pipeline. */
 export interface MakeOptions<Error = never, Context = never> {
-  readonly renderer?: Renderer.Renderer
+  readonly renderer?: Renderer
   readonly driver?: Driver<Error, Context>
   readonly driverMode?: CoreExecutor.DriverMode
 }
 /** Standard composed error shape for Postgres executors. */
 export type PostgresExecutorError = PostgresDriverError | RowDecodeError
 /** Read-query error surface emitted by built-in Postgres executors. */
-export type PostgresQueryError<PlanValue extends Query.QueryPlan<any, any, any, any, any, any, any, any, any, any>> =
-  Exclude<Query.CapabilitiesOfPlan<PlanValue>, "read"> extends never ? PostgresReadQueryError : PostgresExecutorError
+export type PostgresQueryError<PlanValue extends CoreQuery.QueryPlan<any, any, any, any, any, any, any, any, any, any>> =
+  Exclude<CoreQuery.CapabilitiesOfPlan<PlanValue>, "read"> extends never ? PostgresReadQueryError : PostgresExecutorError
 
 /** Runs an effect within the ambient Postgres SQL transaction service. */
 export const withTransaction = CoreExecutor.withTransaction
@@ -39,9 +41,9 @@ export const withSavepoint = CoreExecutor.withSavepoint
 /** Postgres executor whose error channel narrows based on the query plan. */
 export interface QueryExecutor<Context = never> {
   readonly dialect: "postgres"
-  execute<PlanValue extends Query.QueryPlan<any, any, any, any, any, any, any, any, any, any>>(
-    plan: Query.DialectCompatiblePlan<PlanValue, "postgres">
-  ): Effect.Effect<Query.ResultRows<PlanValue>, PostgresQueryError<PlanValue>, Context>
+  execute<PlanValue extends CoreQuery.QueryPlan<any, any, any, any, any, any, any, any, any, any>>(
+    plan: CoreQuery.DialectCompatiblePlan<PlanValue, "postgres">
+  ): Effect.Effect<CoreQuery.ResultRows<PlanValue>, PostgresQueryError<PlanValue>, Context>
 }
 
 /** Constructs a Postgres-specialized SQL driver. */
@@ -56,7 +58,7 @@ const fromDriver = <
   Error = never,
   Context = never
 >(
-  renderer: Renderer.Renderer,
+  renderer: Renderer,
   sqlDriver: Driver<Error, Context>,
   driverMode: CoreExecutor.DriverMode = "raw"
 ): QueryExecutor<Context> => ({
@@ -85,7 +87,7 @@ const fromDriver = <
 })
 
 const sqlClientDriver = (): Driver<any, SqlClient.SqlClient> =>
-  driver((query: Renderer.RenderedQuery<any>) =>
+  driver((query: CoreRenderer.RenderedQuery<any, "postgres">) =>
     Effect.flatMap(SqlClient.SqlClient, (sql) =>
       sql.unsafe<FlatRow>(query.sql, [...query.params])))
 
@@ -99,13 +101,13 @@ const sqlClientDriver = (): Driver<any, SqlClient.SqlClient> =>
 export function make(): QueryExecutor<SqlClient.SqlClient>
 export function make(
   options: {
-    readonly renderer?: Renderer.Renderer
+    readonly renderer?: Renderer
     readonly driverMode?: CoreExecutor.DriverMode
   }
 ): QueryExecutor<SqlClient.SqlClient>
 export function make<Error = never, Context = never>(
   options: {
-    readonly renderer?: Renderer.Renderer
+    readonly renderer?: Renderer
     readonly driver: Driver<Error, Context>
     readonly driverMode?: CoreExecutor.DriverMode
   }
@@ -114,9 +116,9 @@ export function make<Error = never, Context = never>(
   options: MakeOptions<Error, Context> = {}
 ): QueryExecutor<any> {
   if (options.driver) {
-    return fromDriver(options.renderer ?? Renderer.make(), options.driver, options.driverMode)
+    return fromDriver(options.renderer ?? CoreRenderer.make("postgres"), options.driver, options.driverMode)
   }
-  return fromDriver(options.renderer ?? Renderer.make(), sqlClientDriver(), options.driverMode)
+  return fromDriver(options.renderer ?? CoreRenderer.make("postgres"), sqlClientDriver(), options.driverMode)
 }
 
 /** Creates a Postgres-specialized executor from a typed implementation callback. */
@@ -124,8 +126,8 @@ export const custom = <
   Error = never,
   Context = never
 >(
-  execute: <PlanValue extends Query.QueryPlan<any, any, any, any, any, any, any, any, any, any>>(
-    plan: Query.DialectCompatiblePlan<PlanValue, "postgres">
-  ) => Effect.Effect<Query.ResultRows<PlanValue>, Error, Context>
+  execute: <PlanValue extends CoreQuery.QueryPlan<any, any, any, any, any, any, any, any, any, any>>(
+    plan: CoreQuery.DialectCompatiblePlan<PlanValue, "postgres">
+  ) => Effect.Effect<CoreQuery.ResultRows<PlanValue>, Error, Context>
 ): Executor<Error, Context> =>
   CoreExecutor.make("postgres", execute as any) as Executor<Error, Context>

package/src/postgres/function/aggregate.ts

@@ -0,0 +1,6 @@
+import { postgresQuery } from "../private/query.js"
+
+/** Postgres aggregate functions. */
+export const count = postgresQuery.count
+export const max = postgresQuery.max
+export const min = postgresQuery.min

package/src/postgres/function/core.ts

@@ -0,0 +1,16 @@
+import type { ExpressionInput } from "../query.js"
+import { postgresQuery } from "../private/query.js"
+import { isSequenceDefinition, type SequenceDefinition } from "../schema-management.js"
+
+/** Postgres scalar core functions. */
+export const coalesce = postgresQuery.coalesce
+export const call = postgresQuery.call
+export const uuidGenerateV4 = postgresQuery.uuidGenerateV4
+export const nextVal = (
+  value: ExpressionInput | SequenceDefinition<string, string | undefined>
+) =>
+  postgresQuery.nextVal(
+    isSequenceDefinition(value)
+      ? postgresQuery.cast(postgresQuery.literal(value.qualifiedName()), postgresQuery.type.regclass())
+      : value
+  )

package/src/postgres/function/index.ts

@@ -0,0 +1,20 @@
+export * as core from "./core.js"
+export * as string from "./string.js"
+export * as aggregate from "./aggregate.js"
+export * as window from "./window.js"
+export { json, jsonb } from "./json.js"
+export * as temporal from "./temporal.js"
+
+export { coalesce } from "./core.js"
+export { call, uuidGenerateV4, nextVal } from "./core.js"
+export { lower, upper, concat } from "./string.js"
+export { count, max, min } from "./aggregate.js"
+export { over, rowNumber, rank, denseRank } from "./window.js"
+export {
+  currentDate,
+  currentTime,
+  currentTimestamp,
+  localTime,
+  localTimestamp,
+  now
+} from "./temporal.js"