effect-qb 0.16.0 → 4.0.0-beta.66

package/src/mysql/query.ts

@@ -16,7 +16,6 @@ import {
   type HavingPredicateInput,
   type OrderDirection,
   type OutputOfSelection,
-  type MutationInputOf,
   type MutationTargetLike,
   type NumericExpressionInput,
   type PredicateInput,
@@ -136,8 +135,17 @@ export {
   orderBy,
   groupBy
 } from "./internal/dsl.js"
+import type * as Expression from "../internal/scalar.js"
 export { mysqlType as type }
 
+type MysqlMutationValueInput<Value> =
+  | Value
+  | Expression.Scalar<Value, Expression.DbType.Any, Expression.Nullability, "mysql", Expression.ScalarKind, Expression.BindingId>
+
+export type MutationInputOf<Shape> = {
+  readonly [K in keyof Shape]: MysqlMutationValueInput<Shape[K]>
+}
+
 type StructuredSource = AnyValuesSource | AnyUnnestSource | AnyTableFunctionSource
 
 type StructuredFromApi = <CurrentSource extends StructuredSource>(
@@ -163,7 +171,6 @@ export type {
   HavingPredicateInput,
   OrderDirection,
   OutputOfSelection,
-  MutationInputOf,
   MutationTargetLike,
   NumericExpressionInput,
   PredicateInput,

package/src/mysql/table.ts

@@ -1,5 +1,3 @@
-import type * as Schema from "effect/Schema"
-
 import type * as Expression from "../internal/scalar.js"
 import { ColumnTypeId, type AnyColumnDefinition } from "../internal/column-state.js"
 import * as BaseTable from "../internal/table.js"
@@ -33,37 +31,43 @@ export type TableClassStatic<
   SchemaName extends string | undefined = undefined
 > = BaseTable.TableClassStatic<Name, Fields, PrimaryKeyColumns, SchemaName>
 
-export type AnyTable = BaseTable.AnyTable
+export type AnyTable = BaseTable.AnyTable<Dialect>
 
-type FieldsOfTable<Table> = Table extends BaseTable.TableDefinition<any, infer Fields extends DialectFieldMap, any, any, any>
+type FieldsOfTable<Table extends BaseTable.AnyTable> = Table[typeof BaseTable.TypeId]["fields"] extends infer Fields extends DialectFieldMap
   ? Fields
-  : Table extends BaseTable.TableClassStatic<any, infer Fields extends DialectFieldMap, any, any>
-    ? Fields
-    : never
-
-type PrimaryKeyOfTable<Table> = Table extends BaseTable.TableDefinition<any, any, infer PrimaryKeyColumns extends string, any, any>
-  ? PrimaryKeyColumns
-  : Table extends BaseTable.TableClassStatic<any, any, infer PrimaryKeyColumns extends string, any>
-    ? PrimaryKeyColumns
-    : never
-
-type SchemaNameOfTable<Table> = Table extends BaseTable.TableDefinition<any, any, any, any, infer SchemaName>
-  ? SchemaName
-  : Table extends BaseTable.TableClassStatic<any, any, any, infer SchemaName>
-    ? SchemaName
-    : never
+  : never
+
+type ColumnNamesOfTable<Table extends BaseTable.AnyTable> = Extract<keyof FieldsOfTable<Table>, string>
+
+type PrimaryKeyOfTable<Table extends BaseTable.AnyTable> = Table[typeof BaseTable.TypeId]["primaryKey"][number]
+
+type SchemaNameOfTable<Table extends BaseTable.AnyTable> = Table[typeof BaseTable.TypeId]["schemaName"]
+
+type ApplySchemaTableOptions<
+  Name extends string,
+  Fields extends DialectFieldMap,
+  PrimaryKeyColumns extends keyof Fields & string,
+  SchemaName extends string,
+  Options extends BaseTable.DeclaredTableOptions
+> = BaseTable.ApplyDeclaredOptions<
+  BaseTable.TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", SchemaName>,
+  Options
+> extends BaseTable.TableDefinition<any, any, infer AppliedPrimaryKeyColumns extends keyof Fields & string, "schema", any>
+  ? TableDefinition<Name, Fields, AppliedPrimaryKeyColumns, "schema", SchemaName>
+  : TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", SchemaName>
 
 export type TableSchemaNamespace<SchemaName extends string> = {
   readonly schemaName: SchemaName
   readonly table: <
     Name extends string,
     Fields extends DialectFieldMap,
+    const Options extends BaseTable.DeclaredTableOptions,
     PrimaryKeyColumns extends keyof Fields & string = InlinePrimaryKeyKeys<Fields>
   >(
     name: Name,
     fields: Fields,
-    ...options: BaseTable.DeclaredTableOptions
-  ) => TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", SchemaName>
+    ...options: Options & BaseTable.ValidateDeclaredOptions<BaseTable.TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", SchemaName>, Options>
+  ) => ApplySchemaTableOptions<Name, Fields, PrimaryKeyColumns, SchemaName, Options>
 }
 
 export type TableOption = BaseTable.TableOption
@@ -85,23 +89,31 @@ export const make = <
 
 export const schema = <SchemaName extends string>(
   schemaName: SchemaName
-): TableSchemaNamespace<SchemaName> => ({
-  schemaName,
-  table: <
+): TableSchemaNamespace<SchemaName> => {
+  const table = <
     Name extends string,
     Fields extends DialectFieldMap,
+    const Options extends BaseTable.DeclaredTableOptions,
     PrimaryKeyColumns extends keyof Fields & string = InlinePrimaryKeyKeys<Fields>
   >(
     name: Name,
     fields: Fields,
-    ...declaredOptions: BaseTable.DeclaredTableOptions
+    ...declaredOptions: Options & BaseTable.ValidateDeclaredOptions<BaseTable.TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", SchemaName>, Options>
   ) =>
-    BaseTable.schema(schemaName).table(
+    (BaseTable.schema(schemaName).table as (
+      name: Name,
+      fields: Fields,
+      ...options: BaseTable.DeclaredTableOptions
+    ) => BaseTable.TableDefinition<any, any, any, "schema", any>)(
       name,
       fields,
       ...declaredOptions
-    ) as TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", SchemaName>
-})
+    ) as ApplySchemaTableOptions<Name, Fields, PrimaryKeyColumns, SchemaName, Options>
+  return {
+    schemaName,
+    table
+  } as unknown as TableSchemaNamespace<SchemaName>
+}
 
 export const alias = <
   Table extends AnyTable,
@@ -144,14 +156,31 @@ export const foreignKey = <
   TargetTable extends AnyTable,
   TargetColumns extends string | readonly string[]
 >(
-  columns: LocalColumns,
+  columns: LocalColumns & BaseTable.NonEmptyColumnInput<LocalColumns>,
   target: () => TargetTable,
-  referencedColumns: TargetColumns
-): BaseTable.TableOption =>
-  BaseTable.foreignKey(columns, target as () => BaseTable.AnyTable, referencedColumns)
+  referencedColumns: TargetColumns & BaseTable.NonEmptyColumnInput<TargetColumns> & BaseTable.MatchingColumnArityInput<LocalColumns, TargetColumns>
+): BaseTable.TableOption<{
+  readonly kind: "foreignKey"
+  readonly columns: BaseTable.NormalizeColumns<LocalColumns>
+  readonly references: () => {
+    readonly tableName: string
+    readonly schemaName?: string
+    readonly columns: BaseTable.NormalizeColumns<TargetColumns>
+    readonly knownColumns: readonly ColumnNamesOfTable<TargetTable>[]
+  }
+}> =>
+  BaseTable.foreignKey<LocalColumns, TargetTable, TargetColumns>(
+    columns as LocalColumns & BaseTable.NonEmptyColumnInput<LocalColumns>,
+    target,
+    referencedColumns as TargetColumns & BaseTable.NonEmptyColumnInput<TargetColumns> & BaseTable.MatchingColumnArityInput<LocalColumns, TargetColumns>
+  )
 
 export const check = BaseTable.check
 
-export type SelectOf<Table extends { readonly schemas: { readonly select: Schema.Schema<any> } }> = BaseTable.SelectOf<Table>
-export type InsertOf<Table extends { readonly schemas: { readonly insert: Schema.Schema<any> } }> = BaseTable.InsertOf<Table>
-export type UpdateOf<Table extends { readonly schemas: { readonly update: Schema.Schema<any> } }> = BaseTable.UpdateOf<Table>
+export const selectSchema = BaseTable.selectSchema
+export const insertSchema = BaseTable.insertSchema
+export const updateSchema = BaseTable.updateSchema
+
+export type SelectOf<Table extends AnyTable> = BaseTable.SelectOf<Table>
+export type InsertOf<Table extends AnyTable> = BaseTable.InsertOf<Table>
+export type UpdateOf<Table extends AnyTable> = BaseTable.UpdateOf<Table>

package/src/postgres/column.ts

@@ -29,7 +29,7 @@ const enrichDbType = <Db extends Expression.DbType.Any>(dbType: Db): Db => {
 }
 
 const primitive = <Type, Db extends Expression.DbType.Any>(
-  schema: Schema.Schema<Type, any, any>,
+  schema: Schema.Schema<Type>,
   dbType: Db
 ): ColumnDefinition<Type, Type, Type, Db, false, false, false, false, false, undefined> =>
   makeColumnDefinition(schema as Schema.Schema<NonNullable<Type>>, {
@@ -57,13 +57,15 @@ const renderNumericDdlType = (
 const boundedString = (length?: number): Schema.Schema<string> =>
   length === undefined
     ? Schema.String
-    : Schema.String.pipe(Schema.maxLength(length))
+    : Schema.String.check(Schema.isMaxLength(length))
 
-export const custom = <SchemaType extends Schema.Schema.Any, Db extends Expression.DbType.Any>(
+const finiteNumber = Schema.Number.check(Schema.isFinite())
+
+export const custom = <SchemaType extends Schema.Top, Db extends Expression.DbType.Any>(
   schema: SchemaType,
   dbType: Db
 ) =>
-  makeColumnDefinition(schema as unknown as Schema.Schema<NonNullable<Schema.Schema.Type<SchemaType>>, any, any>, {
+  makeColumnDefinition(schema as unknown as Schema.Schema<NonNullable<Schema.Schema.Type<SchemaType>>>, {
     dbType: enrichDbType(dbType),
     nullable: false,
     hasDefault: false,
@@ -75,7 +77,7 @@ export const custom = <SchemaType extends Schema.Schema.Any, Db extends Expressi
     identity: undefined
   })
 
-export const uuid = () => primitive(Schema.UUID, postgresDatatypes.uuid())
+export const uuid = () => primitive(Schema.String.check(Schema.isUUID()), 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())
@@ -92,8 +94,8 @@ export const number = (options?: BaseColumn.NumericOptions) =>
     ddlType: renderNumericDdlType("numeric", options),
     identity: undefined
   })
-export const float4 = () => primitive(Schema.Number, postgresDatatypes.float4())
-export const float8 = () => primitive(Schema.Number, postgresDatatypes.float8())
+export const float4 = () => primitive(finiteNumber, postgresDatatypes.float4())
+export const float8 = () => primitive(finiteNumber, postgresDatatypes.float8())
 export const boolean = () => primitive(Schema.Boolean, postgresDatatypes.boolean())
 export const date = () => primitive(LocalDateStringSchema, postgresDatatypes.date())
 export const timestamp = () => primitive(LocalDateTimeStringSchema, postgresDatatypes.timestamp())
@@ -101,7 +103,7 @@ export const time = () => primitive(LocalTimeStringSchema, postgresDatatypes.tim
 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 bytea = () => primitive(Schema.Uint8Array, 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())
@@ -133,8 +135,8 @@ export const varchar = (length?: number) =>
     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>, {
+export const json = <SchemaType extends Schema.Top>(schema: SchemaType) =>
+  makeColumnDefinition(schema as unknown as Schema.Schema<NonNullable<Schema.Schema.Type<SchemaType>>>, {
     dbType: postgresDatatypes.json(),
     nullable: false,
     hasDefault: false,
@@ -145,8 +147,8 @@ export const json = <SchemaType extends Schema.Schema.Any>(schema: SchemaType) =
     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>, {
+export const jsonb = <SchemaType extends Schema.Top>(schema: SchemaType) =>
+  makeColumnDefinition(schema as unknown as Schema.Schema<NonNullable<Schema.Schema.Type<SchemaType>>>, {
     dbType: postgresDatatypes.jsonb(),
     nullable: false,
     hasDefault: false,

package/src/postgres/errors/normalize.ts

@@ -44,8 +44,8 @@ const asNumber = (value: unknown): number | undefined => {
   if (typeof value === "number" && Number.isFinite(value)) {
     return value
   }
-  if (typeof value === "string" && value.trim() !== "") {
-    const parsed = Number(value)
+  if (typeof value === "string" && /^[+-]?\d+$/.test(value.trim())) {
+    const parsed = Number(value.trim())
     return Number.isFinite(parsed) ? parsed : undefined
   }
   return undefined

package/src/postgres/executor.ts

@@ -1,5 +1,5 @@
 import * as Effect from "effect/Effect"
-import * as SqlClient from "@effect/sql/SqlClient"
+import * as SqlClient from "effect/unstable/sql/SqlClient"
 import * as Stream from "effect/Stream"
 
 import * as CoreExecutor from "../internal/executor.js"
@@ -55,12 +55,55 @@ export interface QueryExecutor<Context = never> {
   ): Stream.Stream<CoreQuery.ResultRow<PlanValue>, PostgresQueryError<PlanValue>, Context>
 }
 
+type DriverExecute<Error, Context> = <Row>(
+  query: CoreRenderer.RenderedQuery<Row, "postgres">
+) => Effect.Effect<ReadonlyArray<FlatRow>, Error, Context>
+
+type DriverHandlers<Error, Context> = {
+  readonly execute: DriverExecute<Error, Context>
+  readonly stream: <Row>(
+    query: CoreRenderer.RenderedQuery<Row, "postgres">
+  ) => Stream.Stream<FlatRow, Error, Context>
+}
+
 /** Constructs a Postgres-specialized SQL driver. */
-export function driver(execute: any): Driver<any, any>
-export function driver(dialect: "postgres", execute: any): Driver<any, any>
-export function driver(dialectOrExecute: "postgres" | any, maybeExecute?: any): Driver<any, any> {
-  const execute = typeof dialectOrExecute === "string" ? maybeExecute : dialectOrExecute
-  return CoreExecutor.driver("postgres", execute as any)
+export function driver<
+  Error = never,
+  Context = never
+>(
+  execute: DriverExecute<Error, Context>
+): Driver<Error, Context>
+export function driver<
+  Error = never,
+  Context = never
+>(
+  handlers: DriverHandlers<Error, Context>
+): Driver<Error, Context>
+export function driver<
+  Error = never,
+  Context = never
+>(
+  dialect: "postgres",
+  execute: DriverExecute<Error, Context>
+): Driver<Error, Context>
+export function driver<
+  Error = never,
+  Context = never
+>(
+  dialect: "postgres",
+  handlers: DriverHandlers<Error, Context>
+): Driver<Error, Context>
+export function driver<
+  Error = never,
+  Context = never
+>(
+  dialectOrExecute: "postgres" | DriverExecute<Error, Context> | DriverHandlers<Error, Context>,
+  maybeExecute?: DriverExecute<Error, Context> | DriverHandlers<Error, Context>
+): Driver<Error, Context> {
+  const executeOrHandlers = typeof dialectOrExecute === "string" ? maybeExecute : dialectOrExecute
+  return typeof executeOrHandlers === "function"
+    ? CoreExecutor.driver("postgres", executeOrHandlers)
+    : CoreExecutor.driver("postgres", executeOrHandlers as DriverHandlers<Error, Context>)
 }
 
 const fromDriver = <
@@ -97,10 +140,10 @@ const fromDriver = <
   stream(plan) {
     const rendered = renderer.render(plan)
     return Stream.mapError(
-      Stream.mapChunksEffect(
+      Stream.mapArrayEffect(
         sqlDriver.stream(rendered),
         (rows) => Effect.try({
-          try: () => CoreExecutor.decodeChunk(rendered, plan, rows, { driverMode, valueMappings }),
+          try: () => CoreExecutor.decodeRows(rendered, plan, rows, { driverMode, valueMappings }) as never,
           catch: (error) => error as RowDecodeError
         })
       ),
@@ -130,7 +173,7 @@ const sqlClientDriver = (): Driver<any, SqlClient.SqlClient> =>
  * Creates the standard Postgres executor pipeline.
  *
  * By default this uses the built-in Postgres renderer plus the ambient
- * `@effect/sql` `SqlClient`. Advanced callers can override the renderer,
+ * `effect/unstable/sql` `SqlClient`. Advanced callers can override the renderer,
  * driver, or both.
  */
 export function make(): QueryExecutor<SqlClient.SqlClient>

package/src/postgres/function/core.ts

@@ -12,11 +12,29 @@ import { isSequenceDefinition, type SequenceDefinition } from "../schema-managem
 
 /** Postgres scalar core functions. */
 export { coalesce, call, uuidGenerateV4 }
+
+const safeUnquotedIdentifier = /^[a-z_][a-z0-9_$]*$/
+
+const quoteIdentifier = (value: string): string =>
+  `"${value.replaceAll("\"", "\"\"")}"`
+
+const renderIdentifier = (value: string): string =>
+  safeUnquotedIdentifier.test(value)
+    ? value
+    : quoteIdentifier(value)
+
+const renderQualifiedSequenceName = (
+  value: SequenceDefinition<string, string | undefined>
+): string =>
+  value.schemaName === undefined || value.schemaName === "public"
+    ? renderIdentifier(value.name)
+    : `${renderIdentifier(value.schemaName)}.${renderIdentifier(value.name)}`
+
 export const nextVal = (
   value: ExpressionInput | SequenceDefinition<string, string | undefined>
 ) =>
   nextValInternal(
     isSequenceDefinition(value)
-      ? cast(literal(value.qualifiedName()), postgresType.regclass())
+      ? cast(literal(renderQualifiedSequenceName(value)), postgresType.regclass())
       : value
   )

package/src/postgres/function/temporal.ts

@@ -39,7 +39,7 @@ const makeTemporal = <
 >(
   name: Name,
   dbType: Db,
-  runtimeSchema: Schema.Schema<Runtime, any, any>
+  runtimeSchema: Schema.Schema<Runtime>
 ): TemporalExpression<Runtime, Db, Name> =>
   makeExpression({
     runtime: undefined as unknown as Runtime,