effect-qb 0.12.3 → 0.13.0

package/src/mysql/function/string.ts

@@ -0,0 +1,6 @@
+import { mysqlQuery } from "../private/query.js"
+
+/** MySQL string functions. */
+export const lower = mysqlQuery.lower
+export const upper = mysqlQuery.upper
+export const concat = mysqlQuery.concat

package/src/mysql/function/temporal.ts

@@ -0,0 +1,103 @@
+import type * as Schema from "effect/Schema"
+
+import type * as Expression from "../../internal/expression.js"
+import type * as ExpressionAst from "../../internal/expression-ast.js"
+import { makeExpression } from "../../internal/query.js"
+import {
+  LocalDateStringSchema,
+  LocalDateTimeStringSchema,
+  LocalTimeStringSchema,
+  type LocalDateString,
+  type LocalDateTimeString,
+  type LocalTimeString
+} from "../../internal/runtime-value.js"
+
+type TemporalExpression<
+  Runtime,
+  Db extends Expression.DbType.Any,
+  Name extends string
+> = Expression.Expression<
+  Runtime,
+  Db,
+  "never",
+  "mysql",
+  "scalar",
+  never,
+  {},
+  "resolved"
+> & {
+  readonly [ExpressionAst.TypeId]: ExpressionAst.FunctionCallNode<Name, readonly []>
+}
+
+const makeTemporal = <
+  Runtime,
+  Db extends Expression.DbType.Any,
+  Name extends string
+>(
+  name: Name,
+  dbType: Db,
+  runtimeSchema: Schema.Schema<Runtime, any, any>
+): TemporalExpression<Runtime, Db, Name> =>
+  makeExpression({
+    runtime: undefined as unknown as Runtime,
+    dbType,
+    runtimeSchema,
+    nullability: "never",
+    dialect: "mysql",
+    aggregation: "scalar",
+    source: undefined as never,
+    dependencies: {},
+    sourceNullability: "resolved"
+  }, {
+    kind: "function",
+    name,
+    args: []
+  }) as TemporalExpression<Runtime, Db, Name>
+
+/** MySQL current date. */
+export const currentDate = () =>
+  makeTemporal(
+    "current_date",
+    { dialect: "mysql", kind: "date" } as Expression.DbType.MySqlDate,
+    LocalDateStringSchema
+  )
+
+/** MySQL current time. */
+export const currentTime = () =>
+  makeTemporal(
+    "current_time",
+    { dialect: "mysql", kind: "time" } as Expression.DbType.MySqlTime,
+    LocalTimeStringSchema
+  )
+
+/** MySQL current timestamp. */
+export const currentTimestamp = () =>
+  makeTemporal(
+    "current_timestamp",
+    { dialect: "mysql", kind: "timestamp" } as Expression.DbType.MySqlTimestamp,
+    LocalDateTimeStringSchema
+  )
+
+/** MySQL local time. */
+export const localTime = () =>
+  makeTemporal(
+    "localtime",
+    { dialect: "mysql", kind: "time" } as Expression.DbType.MySqlTime,
+    LocalTimeStringSchema
+  )
+
+/** MySQL local timestamp. */
+export const localTimestamp = () =>
+  makeTemporal(
+    "localtimestamp",
+    { dialect: "mysql", kind: "timestamp" } as Expression.DbType.MySqlTimestamp,
+    LocalDateTimeStringSchema
+  )
+
+/** MySQL current instant-like timestamp. */
+export const now = () =>
+  makeTemporal(
+    "now",
+    { dialect: "mysql", kind: "timestamp" } as Expression.DbType.MySqlTimestamp,
+    LocalDateTimeStringSchema
+  )

package/src/mysql/function/window.ts

@@ -0,0 +1,7 @@
+import { mysqlQuery } from "../private/query.js"
+
+/** MySQL window functions. */
+export const over = mysqlQuery.over
+export const rowNumber = mysqlQuery.rowNumber
+export const rank = mysqlQuery.rank
+export const denseRank = mysqlQuery.denseRank

package/src/mysql/private/query.ts

@@ -0,0 +1,13 @@
+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/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,11 @@ 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 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,8 +48,6 @@ 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 and = mysqlQuery.and
@@ -72,22 +57,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 +79,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/column.ts

@@ -1,8 +1,8 @@
 export {
   boolean,
   date,
+  default_ as default,
   generated,
-  hasDefault,
   int,
   json,
   nullable,

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,4 @@
+import { postgresQuery } from "../private/query.js"
+
+/** Postgres scalar core functions. */
+export const coalesce = postgresQuery.coalesce

package/src/postgres/function/index.ts

@@ -0,0 +1,19 @@
+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 } from "./json.js"
+export * as temporal from "./temporal.js"
+
+export { coalesce } 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"

package/src/postgres/function/json.ts

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

package/src/postgres/function/string.ts

@@ -0,0 +1,6 @@
+import { postgresQuery } from "../private/query.js"
+
+/** Postgres string functions. */
+export const lower = postgresQuery.lower
+export const upper = postgresQuery.upper
+export const concat = postgresQuery.concat

package/src/postgres/function/temporal.ts

@@ -0,0 +1,107 @@
+import type * as Schema from "effect/Schema"
+
+import type * as Expression from "../../internal/expression.js"
+import type * as ExpressionAst from "../../internal/expression-ast.js"
+import { makeExpression } from "../../internal/query.js"
+import {
+  InstantStringSchema,
+  LocalDateStringSchema,
+  LocalDateTimeStringSchema,
+  LocalTimeStringSchema,
+  OffsetTimeStringSchema,
+  type InstantString,
+  type LocalDateString,
+  type LocalDateTimeString,
+  type LocalTimeString,
+  type OffsetTimeString
+} from "../../internal/runtime-value.js"
+
+type TemporalExpression<
+  Runtime,
+  Db extends Expression.DbType.Any,
+  Name extends string
+> = Expression.Expression<
+  Runtime,
+  Db,
+  "never",
+  "postgres",
+  "scalar",
+  never,
+  {},
+  "resolved"
+> & {
+  readonly [ExpressionAst.TypeId]: ExpressionAst.FunctionCallNode<Name, readonly []>
+}
+
+const makeTemporal = <
+  Runtime,
+  Db extends Expression.DbType.Any,
+  Name extends string
+>(
+  name: Name,
+  dbType: Db,
+  runtimeSchema: Schema.Schema<Runtime, any, any>
+): TemporalExpression<Runtime, Db, Name> =>
+  makeExpression({
+    runtime: undefined as unknown as Runtime,
+    dbType,
+    runtimeSchema,
+    nullability: "never",
+    dialect: "postgres",
+    aggregation: "scalar",
+    source: undefined as never,
+    dependencies: {},
+    sourceNullability: "resolved"
+  }, {
+    kind: "function",
+    name,
+    args: []
+  }) as TemporalExpression<Runtime, Db, Name>
+
+/** Postgres current instant. */
+export const now = () =>
+  makeTemporal(
+    "now",
+    { dialect: "postgres", kind: "timestamptz" } as Expression.DbType.PgTimestamptz,
+    InstantStringSchema
+  )
+
+/** Postgres current date. */
+export const currentDate = () =>
+  makeTemporal(
+    "current_date",
+    { dialect: "postgres", kind: "date" } as Expression.DbType.PgDate,
+    LocalDateStringSchema
+  )
+
+/** Postgres current time with time zone. */
+export const currentTime = () =>
+  makeTemporal(
+    "current_time",
+    { dialect: "postgres", kind: "timetz" } as Expression.DbType.PgTimetz,
+    OffsetTimeStringSchema
+  )
+
+/** Postgres current timestamp with time zone. */
+export const currentTimestamp = () =>
+  makeTemporal(
+    "current_timestamp",
+    { dialect: "postgres", kind: "timestamptz" } as Expression.DbType.PgTimestamptz,
+    InstantStringSchema
+  )
+
+/** Postgres local time without time zone. */
+export const localTime = () =>
+  makeTemporal(
+    "localtime",
+    { dialect: "postgres", kind: "time" } as Expression.DbType.PgTime,
+    LocalTimeStringSchema
+  )
+
+/** Postgres local timestamp without time zone. */
+export const localTimestamp = () =>
+  makeTemporal(
+    "localtimestamp",
+    { dialect: "postgres", kind: "timestamp" } as Expression.DbType.PgTimestamp,
+    LocalDateTimeStringSchema
+  )

package/src/postgres/function/window.ts

@@ -0,0 +1,7 @@
+import { postgresQuery } from "../private/query.js"
+
+/** Postgres window functions. */
+export const over = postgresQuery.over
+export const rowNumber = postgresQuery.rowNumber
+export const rank = postgresQuery.rank
+export const denseRank = postgresQuery.denseRank

package/src/postgres/private/query.ts

@@ -0,0 +1,13 @@
+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
+})

package/src/postgres/query.ts

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

package/src/postgres.ts

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