effect-qb 0.14.0 → 0.15.0

package/src/mysql/json.ts

@@ -0,0 +1,2 @@
+/** MySQL JSON expression helpers. */
+export { json } from "./internal/dsl.js"

package/src/mysql/query.ts

@@ -1,4 +1,7 @@
 import {
+  type AnyTableFunctionSource,
+  type AnyUnnestSource,
+  type AnyValuesSource,
   type CapabilitiesOfPlan,
   type CompletePlan,
   type DialectCompatiblePlan,
@@ -35,98 +38,115 @@ import {
   type StatementOfPlan,
   type StringExpressionInput
 } from "../internal/query.js"
-import { mysqlQuery } from "./private/query.js"
+import {
+  type PublicNonStructuredFromApi,
+  type PublicStructuredFromConstraint,
+  type PublicStructuredFromResult,
+  type as mysqlType,
+  values,
+  unnest,
+  select,
+  insert,
+  from as dslFrom
+} from "./internal/dsl.js"
+
+export {
+  literal,
+  column,
+  cast,
+  eq,
+  neq,
+  lt,
+  lte,
+  gt,
+  gte,
+  isNull,
+  isNotNull,
+  like,
+  ilike,
+  regexMatch,
+  regexIMatch,
+  regexNotMatch,
+  regexNotIMatch,
+  and,
+  or,
+  not,
+  all,
+  any,
+  case_ as case,
+  match,
+  in_ as in,
+  notIn,
+  between,
+  contains,
+  containedBy,
+  overlaps,
+  exists,
+  isDistinctFrom,
+  isNotDistinctFrom,
+  excluded,
+  as,
+  with_ as with,
+  withRecursive,
+  lateral,
+  scalar,
+  inSubquery,
+  compareAny,
+  compareAll,
+  generateSeries,
+  values,
+  unnest,
+  select,
+  returning,
+  onConflict,
+  insert,
+  update,
+  upsert,
+  delete_ as delete,
+  truncate,
+  merge,
+  transaction,
+  commit,
+  rollback,
+  savepoint,
+  rollbackTo,
+  releaseSavepoint,
+  createTable,
+  dropTable,
+  createIndex,
+  dropIndex,
+  union,
+  unionAll,
+  intersect,
+  intersectAll,
+  except,
+  exceptAll,
+  where,
+  having,
+  innerJoin,
+  leftJoin,
+  rightJoin,
+  fullJoin,
+  crossJoin,
+  distinct,
+  distinctOn,
+  limit,
+  offset,
+  lock,
+  orderBy,
+  groupBy
+} from "./internal/dsl.js"
+export { mysqlType as type }
+
+type StructuredSource = AnyValuesSource | AnyUnnestSource | AnyTableFunctionSource
+
+type StructuredFromApi = <CurrentSource extends StructuredSource>(
+  source: CurrentSource
+) => <PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>>(
+  plan: PlanValue & PublicStructuredFromConstraint<PlanValue, CurrentSource, "mysql">
+) => PublicStructuredFromResult<PlanValue, CurrentSource, "mysql">
 
-export const literal = mysqlQuery.literal
-export const column = mysqlQuery.column
-export const cast = mysqlQuery.cast
-export const type = mysqlQuery.type
-export const eq = mysqlQuery.eq
-export const neq = mysqlQuery.neq
-export const lt = mysqlQuery.lt
-export const lte = mysqlQuery.lte
-export const gt = mysqlQuery.gt
-export const gte = mysqlQuery.gte
-export const isNull = mysqlQuery.isNull
-export const isNotNull = mysqlQuery.isNotNull
-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
-export const all = mysqlQuery.all
-export const any = mysqlQuery.any
-const case_ = mysqlQuery.case
-export const match = mysqlQuery.match
-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 exists = mysqlQuery.exists
-export const isDistinctFrom = mysqlQuery.isDistinctFrom
-export const isNotDistinctFrom = mysqlQuery.isNotDistinctFrom
-export const excluded = mysqlQuery.excluded
-export const as = mysqlQuery.as
-export const with_ = mysqlQuery.with
-export const withRecursive = mysqlQuery.withRecursive
-export const lateral = mysqlQuery.lateral
-export const scalar = mysqlQuery.scalar
-export const inSubquery = mysqlQuery.inSubquery
-export const compareAny = mysqlQuery.compareAny
-export const compareAll = mysqlQuery.compareAll
-export const values = mysqlQuery.values
-export const unnest = mysqlQuery.unnest
-export const generateSeries = mysqlQuery.generateSeries
-export const returning = mysqlQuery.returning
-export const onConflict = mysqlQuery.onConflict
-export const insert = mysqlQuery.insert
-export const update = mysqlQuery.update
-export const upsert = mysqlQuery.upsert
-export const delete_ = mysqlQuery.delete
-export const truncate = mysqlQuery.truncate
-export const merge = mysqlQuery.merge
-export const transaction = mysqlQuery.transaction
-export const commit = mysqlQuery.commit
-export const rollback = mysqlQuery.rollback
-export const savepoint = mysqlQuery.savepoint
-export const rollbackTo = mysqlQuery.rollbackTo
-export const releaseSavepoint = mysqlQuery.releaseSavepoint
-export const createTable = mysqlQuery.createTable
-export const dropTable = mysqlQuery.dropTable
-export const createIndex = mysqlQuery.createIndex
-export const dropIndex = mysqlQuery.dropIndex
-export const union = mysqlQuery.union
-export const unionAll = mysqlQuery.unionAll
-export const intersect = mysqlQuery.intersect
-export const intersectAll = mysqlQuery.intersectAll
-export const except = mysqlQuery.except
-export const exceptAll = mysqlQuery.exceptAll
-export const select = mysqlQuery.select
-export const where = mysqlQuery.where
-export const having = mysqlQuery.having
-export const from = mysqlQuery.from
-export const innerJoin = mysqlQuery.innerJoin
-export const leftJoin = mysqlQuery.leftJoin
-export const rightJoin = mysqlQuery.rightJoin
-export const fullJoin = mysqlQuery.fullJoin
-export const crossJoin = mysqlQuery.crossJoin
-export const distinct = mysqlQuery.distinct
-export const distinctOn = mysqlQuery.distinctOn
-export const limit = mysqlQuery.limit
-export const offset = mysqlQuery.offset
-export const lock = mysqlQuery.lock
-export const orderBy = mysqlQuery.orderBy
-export const groupBy = mysqlQuery.groupBy
-export { case_ as case }
-export { in_ as in }
-export { with_ as with }
-export { delete_ as delete }
+export const from: StructuredFromApi & PublicNonStructuredFromApi = dslFrom as StructuredFromApi & PublicNonStructuredFromApi
 
 export type {
   CapabilitiesOfPlan,

package/src/mysql/renderer.ts

@@ -1,5 +1,5 @@
 import * as CoreRenderer from "../internal/renderer.js"
-import { renderMysqlPlan } from "../internal/mysql-renderer.js"
+import { renderMysqlPlan } from "./internal/renderer.js"
 
 /** MySQL-specialized rendered query shape. */
 export type RenderedQuery<Row> = CoreRenderer.RenderedQuery<Row, "mysql">

package/src/mysql/table.ts

@@ -1,6 +1,6 @@
 import type * as Schema from "effect/Schema"
 
-import type * as Expression from "../internal/expression.js"
+import type * as Expression from "../internal/scalar.js"
 import { ColumnTypeId, type AnyColumnDefinition } from "../internal/column-state.js"
 import * as BaseTable from "../internal/table.js"
 

package/src/mysql.ts

@@ -4,14 +4,16 @@ export * as Column from "./mysql/column.js"
 export * as Datatypes from "./mysql/datatypes/index.js"
 /** MySQL error catalog and error normalization helpers. */
 export * as Errors from "./mysql/errors/index.js"
-/** Shared scalar SQL expression interfaces and DB-type descriptors. */
-export * as Expression from "./internal/expression.js"
+/** Shared scalar SQL interfaces and DB-type descriptors. */
+export * as Scalar from "./internal/scalar.js"
 /** MySQL-specialized SQL function expressions. */
 export * as Function from "./mysql/function/index.js"
+/** MySQL-specialized JSON expression helpers. */
+export * as Json from "./mysql/json.js"
 /** MySQL-specialized typed query execution contracts. */
 export * as Executor from "./mysql/executor.js"
-/** Shared logical query-plan interfaces. */
-export * as Plan from "./internal/plan.js"
+/** Shared logical row-set interfaces. */
+export * as RowSet from "./internal/row-set.js"
 /** MySQL-specialized query-construction DSL. */
 export * as Query from "./mysql/query.js"
 /** MySQL-specialized table-definition DSL. */

package/src/postgres/cast.ts

@@ -1,17 +1,16 @@
-import type * as Expression from "../internal/expression.js"
-import { postgresQuery } from "./private/query.js"
+import type * as Expression from "../internal/scalar.js"
+import type { ExpressionInput } from "../internal/query.js"
+import { cast as postgresCast } from "./internal/dsl.js"
 
-type CastInput = Parameters<typeof postgresQuery.cast>[0]
-type CastTarget = Parameters<typeof postgresQuery.cast>[1]
-type CastExpression<Target extends CastTarget> = Expression.Expression<
+type CastInput = ExpressionInput
+type CastTarget = Expression.DbType.Any
+type CastExpression<Target extends CastTarget> = Expression.Scalar<
   Expression.RuntimeOfDbType<Target>,
   Target,
   Expression.Nullability,
-  string,
-  Expression.AggregationKind,
-  any,
-  Expression.SourceDependencies,
-  Expression.SourceNullabilityMode
+  Target["dialect"],
+  Expression.ScalarKind,
+  Expression.BindingId
 >
 
 const to: {
@@ -24,8 +23,8 @@ const to: {
   ): <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
+    ? ((value: CastInput) => postgresCast(value as never, args[0] as never))
+    : postgresCast(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,46 +1,178 @@
-export {
-  brand,
-  ddlType,
-  int2,
-  boolean,
-  date,
-  default_ as default,
-  int8,
-  float4,
-  float8,
-  generated,
-  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,
-  schema,
-  text,
-  timestamp,
-  custom,
-  unique,
-  uuid
-} from "../internal/column.js"
-
-export type { Any, AnyBound } from "../internal/column.js"
+import * as Schema from "effect/Schema"
+
+import * as BaseColumn from "../internal/column.js"
+import { makeColumnDefinition, type ColumnDefinition } from "../internal/column-state.js"
+import type * as Expression from "../internal/scalar.js"
+import {
+  BigIntStringSchema,
+  DecimalStringSchema,
+  InstantStringSchema,
+  LocalDateStringSchema,
+  LocalDateTimeStringSchema,
+  LocalTimeStringSchema,
+  OffsetTimeStringSchema,
+  type BigIntString,
+  type DecimalString,
+  type InstantString,
+  type LocalDateString,
+  type LocalDateTimeString,
+  type LocalTimeString,
+  type OffsetTimeString
+} from "../internal/runtime/value.js"
+import { postgresDatatypes } from "./datatypes/index.js"
+
+const enrichDbType = <Db extends Expression.DbType.Any>(dbType: Db): Db => {
+  const candidate = (postgresDatatypes as unknown as Record<string, (() => Expression.DbType.Any) | undefined>)[dbType.kind]
+  return typeof candidate === "function"
+    ? { ...candidate(), ...dbType } as Db
+    : dbType
+}
+
+const primitive = <Type, Db extends Expression.DbType.Any>(
+  schema: Schema.Schema<Type, any, any>,
+  dbType: Db
+): ColumnDefinition<Type, Type, Type, Db, false, false, false, false, false, undefined> =>
+  makeColumnDefinition(schema as Schema.Schema<NonNullable<Type>>, {
+    dbType,
+    nullable: false,
+    hasDefault: false,
+    generated: false,
+    primaryKey: false,
+    unique: false,
+    references: undefined
+  })
+
+const renderNumericDdlType = (
+  kind: string,
+  options?: BaseColumn.NumericOptions
+): string | undefined => {
+  if (options === undefined || options.precision === undefined) {
+    return undefined
+  }
+  return options.scale === undefined
+    ? `${kind}(${options.precision})`
+    : `${kind}(${options.precision},${options.scale})`
+}
+
+const boundedString = (length?: number): Schema.Schema<string> =>
+  length === undefined
+    ? Schema.String
+    : Schema.String.pipe(Schema.maxLength(length))
+
+export const custom = <SchemaType extends Schema.Schema.Any, Db extends Expression.DbType.Any>(
+  schema: SchemaType,
+  dbType: Db
+) =>
+  makeColumnDefinition(schema as unknown as Schema.Schema<NonNullable<Schema.Schema.Type<SchemaType>>, any, any>, {
+    dbType: enrichDbType(dbType),
+    nullable: false,
+    hasDefault: false,
+    generated: false,
+    primaryKey: false,
+    unique: false,
+    references: undefined,
+    ddlType: undefined,
+    identity: undefined
+  })
+
+export const uuid = () => primitive(Schema.UUID, postgresDatatypes.uuid())
+export const text = () => primitive(Schema.String, postgresDatatypes.text())
+export const int = () => primitive(Schema.Int, postgresDatatypes.int4())
+export const int2 = () => primitive(Schema.Int, postgresDatatypes.int2())
+export const int8 = () => primitive(BigIntStringSchema, postgresDatatypes.int8())
+export const number = (options?: BaseColumn.NumericOptions) =>
+  makeColumnDefinition(DecimalStringSchema, {
+    dbType: postgresDatatypes.numeric(),
+    nullable: false,
+    hasDefault: false,
+    generated: false,
+    primaryKey: false,
+    unique: false,
+    references: undefined,
+    ddlType: renderNumericDdlType("numeric", options),
+    identity: undefined
+  })
+export const float4 = () => primitive(Schema.Number, postgresDatatypes.float4())
+export const float8 = () => primitive(Schema.Number, postgresDatatypes.float8())
+export const boolean = () => primitive(Schema.Boolean, postgresDatatypes.boolean())
+export const date = () => primitive(LocalDateStringSchema, postgresDatatypes.date())
+export const timestamp = () => primitive(LocalDateTimeStringSchema, postgresDatatypes.timestamp())
+export const time = () => primitive(LocalTimeStringSchema, postgresDatatypes.time())
+export const timetz = () => primitive(OffsetTimeStringSchema, postgresDatatypes.timetz())
+export const timestamptz = () => primitive(InstantStringSchema, postgresDatatypes.timestamptz())
+export const interval = () => primitive(Schema.String, postgresDatatypes.interval())
+export const bytea = () => primitive(Schema.Uint8ArrayFromSelf, postgresDatatypes.bytea())
+export const name = () => primitive(Schema.String, postgresDatatypes.name())
+export const oid = () => primitive(Schema.Int, postgresDatatypes.oid())
+export const regclass = () => primitive(Schema.String, postgresDatatypes.regclass())
+export const bit = () => primitive(Schema.String, postgresDatatypes.bit())
+export const varbit = () => primitive(Schema.String, postgresDatatypes.varbit())
+export const xml = () => primitive(Schema.String, postgresDatatypes.xml())
+export const pg_lsn = () => primitive(Schema.String, postgresDatatypes.pg_lsn())
+export const char = (length = 1) =>
+  makeColumnDefinition(boundedString(length), {
+    dbType: postgresDatatypes.char(),
+    nullable: false,
+    hasDefault: false,
+    generated: false,
+    primaryKey: false,
+    unique: false,
+    references: undefined,
+    ddlType: `char(${length})`,
+    identity: undefined
+  })
+export const varchar = (length?: number) =>
+  makeColumnDefinition(boundedString(length), {
+    dbType: postgresDatatypes.varchar(),
+    nullable: false,
+    hasDefault: false,
+    generated: false,
+    primaryKey: false,
+    unique: false,
+    references: undefined,
+    ddlType: length === undefined ? "varchar" : `varchar(${length})`,
+    identity: undefined
+  })
+export const json = <SchemaType extends Schema.Schema.Any>(schema: SchemaType) =>
+  makeColumnDefinition(schema as unknown as Schema.Schema<NonNullable<Schema.Schema.Type<SchemaType>>, any, any>, {
+    dbType: postgresDatatypes.json(),
+    nullable: false,
+    hasDefault: false,
+    generated: false,
+    primaryKey: false,
+    unique: false,
+    references: undefined,
+    ddlType: undefined,
+    identity: undefined
+  })
+export const jsonb = <SchemaType extends Schema.Schema.Any>(schema: SchemaType) =>
+  makeColumnDefinition(schema as unknown as Schema.Schema<NonNullable<Schema.Schema.Type<SchemaType>>, any, any>, {
+    dbType: postgresDatatypes.jsonb(),
+    nullable: false,
+    hasDefault: false,
+    generated: false,
+    primaryKey: false,
+    unique: false,
+    references: undefined,
+    ddlType: undefined,
+    identity: undefined
+  })
+
+export const nullable = BaseColumn.nullable
+export const brand = BaseColumn.brand
+export const primaryKey = BaseColumn.primaryKey
+export const unique = BaseColumn.unique
+const default_ = BaseColumn.default_
+export const generated = BaseColumn.generated
+export const ddlType = BaseColumn.ddlType
+export const array = BaseColumn.array
+export const identityAlways = BaseColumn.identityAlways
+export const identityByDefault = BaseColumn.identityByDefault
+export const foreignKey = BaseColumn.foreignKey
+export const index = BaseColumn.index
+export const references = BaseColumn.references
+export const schema = BaseColumn.schema
+export { default_ as default }
+
+export type Any = BaseColumn.Any
+export type AnyBound = BaseColumn.AnyBound