effect-qb 0.16.0 → 0.17.0

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

@@ -53,17 +53,31 @@ type SchemaNameOfTable<Table> = Table extends BaseTable.TableDefinition<any, any
     ? SchemaName
     : never
 
+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 +99,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,11 +166,15 @@ export const foreignKey = <
   TargetTable extends AnyTable,
   TargetColumns extends string | readonly string[]
 >(
-  columns: LocalColumns,
+  columns: LocalColumns & BaseTable.NonEmptyColumnInput<LocalColumns>,
   target: () => TargetTable,
-  referencedColumns: TargetColumns
+  referencedColumns: TargetColumns & BaseTable.NonEmptyColumnInput<TargetColumns> & BaseTable.MatchingColumnArityInput<LocalColumns, TargetColumns>
 ): BaseTable.TableOption =>
-  BaseTable.foreignKey(columns, target as () => BaseTable.AnyTable, referencedColumns)
+  BaseTable.foreignKey<LocalColumns, BaseTable.AnyTable, TargetColumns>(
+    columns as LocalColumns & BaseTable.NonEmptyColumnInput<LocalColumns>,
+    target as () => BaseTable.AnyTable,
+    referencedColumns as TargetColumns & BaseTable.NonEmptyColumnInput<TargetColumns> & BaseTable.MatchingColumnArityInput<LocalColumns, TargetColumns>
+  )
 
 export const check = BaseTable.check
 

package/src/postgres/column.ts

@@ -59,6 +59,8 @@ const boundedString = (length?: number): Schema.Schema<string> =>
     ? Schema.String
     : Schema.String.pipe(Schema.maxLength(length))
 
+const finiteNumber = Schema.Number.pipe(Schema.finite())
+
 export const custom = <SchemaType extends Schema.Schema.Any, Db extends Expression.DbType.Any>(
   schema: SchemaType,
   dbType: Db
@@ -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())

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

@@ -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 = <

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
   )