effect-qb 0.19.0 → 0.21.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-qb",
-  "version": "0.19.0",
+  "version": "0.21.0",
   "type": "module",
   "license": "MIT",
   "repository": {
@@ -12,8 +12,7 @@
   },
   "homepage": "https://github.com/relsunkaev/effect-qb#readme",
   "engines": {
-    "node": ">=22",
-    "bun": ">=1.3.5"
+    "node": ">=22"
   },
   "files": [
     "dist",
@@ -65,8 +64,6 @@
     "pgsql-ast-parser": "^12.0.2"
   },
   "peerDependencies": {
-    "@effect/experimental": "^0.57.0",
-    "@effect/sql": "^0.48.0",
-    "effect": "^3.19.3"
+    "effect": "4.0.0-beta.98"
   }
 }

package/src/internal/coercion/rules.ts

@@ -1,5 +1,11 @@
 import type * as Expression from "../scalar.js"
-import type { CanCastDbType as LookupCanCastDbType, CanCompareDbTypes as LookupCanCompareDbTypes, CanContainDbTypes as LookupCanContainDbTypes, CanTextuallyCoerceDbType as LookupCanTextuallyCoerceDbType } from "../datatypes/lookup.js"
+import type {
+  CanCastDbType as LookupCanCastDbType,
+  CanCompareDbTypes as LookupCanCompareDbTypes,
+  CanContainDbTypes as LookupCanContainDbTypes,
+  CanImplicitlyConvertDbType as LookupCanImplicitlyConvertDbType,
+  CanTextuallyCoerceDbType as LookupCanTextuallyCoerceDbType
+} from "../datatypes/lookup.js"
 
 export type CanCompareDbTypes<
   Left extends Expression.DbType.Any,
@@ -18,6 +24,12 @@ export type CanTextuallyCoerceDbType<
   Dialect extends string
 > = LookupCanTextuallyCoerceDbType<Db, Dialect>
 
+export type CanImplicitlyConvertDbType<
+  Source extends Expression.DbType.Any,
+  Target extends Expression.DbType.Any,
+  Dialect extends string
+> = LookupCanImplicitlyConvertDbType<Source, Target, Dialect>
+
 export type CanCastDbType<
   Source extends Expression.DbType.Any,
   Target extends Expression.DbType.Any,

package/src/internal/column-state.d.ts

@@ -70,7 +70,7 @@ export interface ColumnState<Select, Insert, Update, Db extends Expression.DbTyp
 export interface ColumnDefinition<Select, Insert, Update, Db extends Expression.DbType.Any, Nullable extends boolean, HasDefault extends boolean, Generated extends boolean, PrimaryKey extends boolean, Unique extends boolean, Ref, Dependencies extends Expression.BindingId = never> extends Pipeable, Expression.Scalar<Select, Db, Nullable extends true ? "maybe" : "never", Db["dialect"], "scalar", Dependencies> {
     readonly pipe: Pipeable["pipe"];
     readonly [ColumnTypeId]: ColumnState<Select, Insert, Update, Db, Nullable, HasDefault, Generated, PrimaryKey, Unique, Ref, Dependencies>;
-    readonly schema: Schema.Schema<NonNullable<Select>, any, any>;
+    readonly schema: Schema.Schema<NonNullable<Select>>;
     readonly metadata: {
         readonly dbType: Db;
         readonly nullable: Nullable;
@@ -111,7 +111,7 @@ export type AnyColumnDefinition = ColumnDefinition<any, any, any, Expression.DbT
 /** Convenience alias for any bound column. */
 export type AnyBoundColumn = BoundColumn<any, any, any, Expression.DbType.Any, boolean, boolean, boolean, boolean, boolean, any, string, string, string>;
 /** Constructs a runtime column-definition object from schema and metadata. */
-export declare const makeColumnDefinition: <Select, Insert, Update, Db extends Expression.DbType.Any, Nullable extends boolean, HasDefault extends boolean, Generated extends boolean, PrimaryKey extends boolean, Unique extends boolean, Ref, Dependencies extends string = never>(schema: Schema.Schema<NonNullable<Select>, any, any>, metadata: {
+export declare const makeColumnDefinition: <Select, Insert, Update, Db extends Expression.DbType.Any, Nullable extends boolean, HasDefault extends boolean, Generated extends boolean, PrimaryKey extends boolean, Unique extends boolean, Ref, Dependencies extends string = never>(schema: Schema.Schema<NonNullable<Select>>, metadata: {
     readonly dbType: Db;
     readonly nullable: Nullable;
     readonly hasDefault: HasDefault;
@@ -135,7 +135,7 @@ export declare const makeColumnDefinition: <Select, Insert, Update, Db extends E
     } | undefined;
 }) => ColumnDefinition<Select, Insert, Update, Db, Nullable, HasDefault, Generated, PrimaryKey, Unique, Ref, Dependencies>;
 export declare const remapColumnDefinition: <Select, Insert, Update, Db extends Expression.DbType.Any, Nullable extends boolean, HasDefault extends boolean, Generated extends boolean, PrimaryKey extends boolean, Unique extends boolean, Ref, Dependencies extends string = never>(column: ColumnDefinition<Select, Insert, Update, Db, Nullable, HasDefault, Generated, PrimaryKey, Unique, Ref, Dependencies>, options?: {
-    readonly schema?: Schema.Schema.Any | undefined;
+    readonly schema?: Schema.Top | undefined;
     readonly metadata?: {
         readonly dbType: Db;
         readonly nullable: Nullable;

package/src/internal/column-state.ts

@@ -4,6 +4,7 @@ import * as Schema from "effect/Schema"
 
 import * as Expression from "./scalar.js"
 import * as ExpressionAst from "./expression-ast.js"
+import { withJsonPathAccess, type WithJsonPathAccess } from "./json/path-access.js"
 import type * as Casing from "./casing.js"
 import type * as SchemaExpression from "./schema-expression.js"
 
@@ -124,7 +125,7 @@ export interface ColumnDefinition<
     Ref,
     Dependencies
   >
-  readonly schema: Schema.Schema<NonNullable<Select>, any, any>
+  readonly schema: Schema.Schema<NonNullable<Select>>
   readonly metadata: {
     readonly dbType: Db
     readonly nullable: Nullable
@@ -259,7 +260,7 @@ export const makeColumnDefinition = <
   Ref,
   Dependencies extends Expression.BindingId = never
 >(
-  schema: Schema.Schema<NonNullable<Select>, any, any>,
+  schema: Schema.Schema<NonNullable<Select>>,
   metadata: ColumnDefinition<
     Select,
     Insert,
@@ -273,7 +274,7 @@ export const makeColumnDefinition = <
     Ref,
     Dependencies
   >["metadata"]
-): ColumnDefinition<
+): WithJsonPathAccess<ColumnDefinition<
   Select,
   Insert,
   Update,
@@ -285,7 +286,7 @@ export const makeColumnDefinition = <
   Unique,
   Ref,
   Dependencies
-> => {
+>> => {
   const column = attachPipe(Object.create(ColumnProto))
   column.schema = schema
   column.metadata = metadata
@@ -317,7 +318,7 @@ export const makeColumnDefinition = <
     identity: metadata.identity,
     enum: metadata.enum
   }
-  return column
+  return withJsonPathAccess(column)
 }
 
 export const remapColumnDefinition = <
@@ -347,7 +348,7 @@ export const remapColumnDefinition = <
     Dependencies
   >,
   options: {
-    readonly schema?: Schema.Schema.Any
+    readonly schema?: Schema.Top
     readonly metadata?: ColumnDefinition<
       Select,
       Insert,
@@ -362,7 +363,7 @@ export const remapColumnDefinition = <
       Dependencies
     >["metadata"]
   } = {}
-): ColumnDefinition<
+): WithJsonPathAccess<ColumnDefinition<
   Select,
   Insert,
   Update,
@@ -374,7 +375,7 @@ export const remapColumnDefinition = <
   Unique,
   Ref,
   Dependencies
-> => {
+>> => {
   const schema = options.schema ?? column.schema
   const metadata = options.metadata ?? column.metadata
   const next = attachPipe(Object.create(ColumnProto))
@@ -424,7 +425,7 @@ export const remapColumnDefinition = <
       }
     })[BoundColumnTypeId]
   }
-  return next
+  return withJsonPathAccess(next)
 }
 
 /** Attaches table/column provenance to an existing column definition. */
@@ -474,7 +475,7 @@ export const bindColumn = <
     schemaName,
     casing
   }
-  return bound
+  return withJsonPathAccess(bound) as BoundColumnFrom<Column, TableName, ColumnName, BaseTableName>
 }
 
 /** Extracts the internal state record for a column. */
@@ -513,7 +514,7 @@ export type BoundColumnFrom<
   TableName extends string,
   ColumnName extends string,
   BaseTableName extends string = TableName
-> = BoundColumn<
+> = WithJsonPathAccess<BoundColumn<
   Column["metadata"]["brand"] extends true
     ? BrandedValue<SelectType<Column>, `${TableName}.${ColumnName}`>
     : SelectType<Column>,
@@ -533,4 +534,4 @@ export type BoundColumnFrom<
   TableName,
   ColumnName,
   BaseTableName
->
+>>

package/src/internal/column.ts

@@ -256,21 +256,21 @@ type NonEmptyIndexMetadataInput<Options> =
 
 type SchemaCompatibleColumn<
   Column extends AnyColumnDefinition,
-  SchemaType extends Schema.Schema.Any
-> = [BaseSelectType<Column>] extends [Schema.Schema.Encoded<SchemaType>]
+  SchemaType extends Schema.Top
+> = [BaseSelectType<Column>] extends [Schema.Codec.Encoded<SchemaType>]
   ? Column
   : never
 
 type ColumnSchemaOutput<
   Column extends AnyColumnDefinition,
-  SchemaType extends Schema.Schema.Any
+  SchemaType extends Schema.Top
 > = IsNullable<Column> extends true
   ? Schema.Schema.Type<SchemaType> | null
   : Schema.Schema.Type<SchemaType>
 
 type ColumnWithSchema<
   Column extends AnyColumnDefinition,
-  SchemaType extends Schema.Schema.Any
+  SchemaType extends Schema.Top
 > = ColumnDefinition<
   ColumnSchemaOutput<Column, SchemaType>,
   ColumnSchemaOutput<Column, SchemaType>,
@@ -407,7 +407,7 @@ const isColumnDefinitionValue = (value: unknown): value is AnyColumnDefinition =
   typeof value === "object" && value !== null && ColumnTypeId in value
 
 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>>, {
@@ -432,7 +432,7 @@ type ColumnModule<
   JsonKind extends string
 > = {
   readonly custom: <
-    SchemaType extends Schema.Schema.Any,
+    SchemaType extends Schema.Top,
     Db extends Expression.DbType.Any
   >(
     schema: SchemaType,
@@ -456,7 +456,7 @@ type ColumnModule<
   readonly boolean: () => ColumnDefinition<boolean, boolean, boolean, Expression.DbType.Base<Dialect, BooleanKind>, false, false, false, false, false, undefined>
   readonly date: () => ColumnDefinition<LocalDateString, LocalDateString, LocalDateString, Expression.DbType.Base<Dialect, DateKind>, false, false, false, false, false, undefined>
   readonly timestamp: () => ColumnDefinition<LocalDateTimeString, LocalDateTimeString, LocalDateTimeString, Expression.DbType.Base<Dialect, TimestampKind>, false, false, false, false, false, undefined>
-  readonly json: <SchemaType extends Schema.Schema.Any>(
+  readonly json: <SchemaType extends Schema.Top>(
     schema: SchemaType
   ) => ColumnDefinition<
     Schema.Schema.Type<SchemaType>,
@@ -473,7 +473,7 @@ type ColumnModule<
 }
 
 /** Replaces a column's runtime schema while preserving its SQL type metadata. */
-export const schema = <SchemaType extends Schema.Schema.Any>(nextSchema: SchemaType) =>
+export const schema = <SchemaType extends Schema.Top>(nextSchema: SchemaType) =>
   <Column extends AnyColumnDefinition>(
     column: SchemaCompatibleColumn<Column, SchemaType>
   ): ColumnWithSchema<Column, SchemaType> =>

package/src/internal/datatypes/define.ts

@@ -2,6 +2,10 @@ import type * as Expression from "../scalar.js"
 import type { NonEmptyStringInput } from "../table-options.js"
 import type { DatatypeFamilySpec, DatatypeKindSpec } from "./shape.js"
 
+type ImplicitTargetsOf<Family> = Family extends { readonly implicitTargets: infer Targets extends readonly string[] }
+  ? Targets
+  : readonly []
+
 type DatatypeWitness<
   Dialect extends string,
   Kinds extends Record<string, DatatypeKindSpec>,
@@ -12,6 +16,7 @@ type DatatypeWitness<
   readonly runtime: Kinds[Kind]["runtime"]
   readonly compareGroup: Families[Kinds[Kind]["family"]]["compareGroup"]
   readonly castTargets: Families[Kinds[Kind]["family"]]["castTargets"]
+  readonly implicitTargets: ImplicitTargetsOf<Families[Kinds[Kind]["family"]]>
   readonly traits: Families[Kinds[Kind]["family"]]["traits"]
 }
 

package/src/internal/datatypes/lookup.ts

@@ -27,10 +27,24 @@ type BaseCompareGroupOf<Db extends Expression.DbType.Base<any, any>> =
     : BaseFamilyOf<Db>
 
 type BaseCastTargetsOf<Db extends Expression.DbType.Base<any, any>> =
-  Db extends { readonly castTargets?: readonly (infer Target extends string)[] }
-    ? Target
+  Db extends { readonly castTargets: infer Targets extends readonly string[] }
+    ? Targets[number]
     : never
 
+type BaseImplicitTargetsOf<Db extends Expression.DbType.Base<any, any>> =
+  Db extends { readonly implicitTargets: infer Targets extends readonly string[] }
+    ? Targets[number]
+    : never
+
+type IsCustomBaseDbType<Db extends Expression.DbType.Any> =
+  Db extends Expression.DbType.Json<any, any>
+    ? false
+    : Db extends Expression.DbType.Base<any, any>
+      ? Db extends { readonly family: string }
+        ? false
+        : true
+      : false
+
 type DbTypeCompatibleWithDialect<
   Db extends Expression.DbType.Any,
   Dialect extends string
@@ -106,25 +120,56 @@ export type RuntimeOfDbType<Db extends Expression.DbType.Any> =
                   : unknown
                 : unknown
 
+type HaveSameComparableGroup<
+  Left extends Expression.DbType.Any,
+  Right extends Expression.DbType.Any
+> = CompareGroupOfDbType<Left> extends never
+  ? false
+  : CompareGroupOfDbType<Right> extends never
+    ? false
+    : CompareGroupOfDbType<Left> extends "null"
+      ? false
+      : CompareGroupOfDbType<Right> extends "null"
+        ? false
+        : [CompareGroupOfDbType<Left>] extends [CompareGroupOfDbType<Right>]
+          ? [CompareGroupOfDbType<Right>] extends [CompareGroupOfDbType<Left>]
+            ? true
+            : false
+          : false
+
+export type CanImplicitlyConvertDbType<
+  Source extends Expression.DbType.Any,
+  Target extends Expression.DbType.Any,
+  Dialect extends string
+> = DbTypeCompatibleWithDialect<Source, Dialect> extends true
+  ? DbTypeCompatibleWithDialect<Target, Dialect> extends true
+    ? Source extends Expression.DbType.Domain<any, infer Base extends Expression.DbType.Any, any>
+      ? CanImplicitlyConvertDbType<Base, Target, Dialect>
+      : Target extends Expression.DbType.Domain<any, infer TargetBase extends Expression.DbType.Any, any>
+        ? CanImplicitlyConvertDbType<Source, TargetBase, Dialect>
+        : HaveSameComparableGroup<Source, Target> extends true
+          ? true
+          : Source extends Expression.DbType.Base<any, any>
+            ? FamilyOfDbType<Target> extends BaseImplicitTargetsOf<Source>
+              ? true
+              : false
+            : false
+    : false
+  : false
+
 export type CanCompareDbTypes<
   Left extends Expression.DbType.Any,
   Right extends Expression.DbType.Any,
   Dialect extends string
 > = DbTypeCompatibleWithDialect<Left, Dialect> extends true
   ? DbTypeCompatibleWithDialect<Right, Dialect> extends true
-    ? CompareGroupOfDbType<Left> extends never
-      ? false
-      : CompareGroupOfDbType<Right> extends never
-        ? false
-        : CompareGroupOfDbType<Left> extends "null"
-          ? false
-          : CompareGroupOfDbType<Right> extends "null"
-            ? false
-            : [CompareGroupOfDbType<Left>] extends [CompareGroupOfDbType<Right>]
-              ? [CompareGroupOfDbType<Right>] extends [CompareGroupOfDbType<Left>]
-                ? true
-                : false
-              : false
+    ? HaveSameComparableGroup<Left, Right> extends true
+      ? true
+      : CanImplicitlyConvertDbType<Left, Right, Dialect> extends true
+        ? true
+        : CanImplicitlyConvertDbType<Right, Left, Dialect> extends true
+          ? true
+          : false
     : false
   : false
 
@@ -171,7 +216,11 @@ export type CanCastDbType<
       ? CanCastDbType<Base, Target, Dialect>
       : Target extends Expression.DbType.Domain<any, infer TargetBase extends Expression.DbType.Any, any>
         ? CanCastDbType<Source, TargetBase, Dialect>
-        : [CompareGroupOfDbType<Source>] extends [CompareGroupOfDbType<Target>]
+        : IsCustomBaseDbType<Source> extends true
+          ? true
+          : IsCustomBaseDbType<Target> extends true
+            ? true
+            : [CompareGroupOfDbType<Source>] extends [CompareGroupOfDbType<Target>]
           ? [CompareGroupOfDbType<Target>] extends [CompareGroupOfDbType<Source>]
             ? true
             : false
@@ -185,9 +234,9 @@ export type CanCastDbType<
             ? true
             : Source extends Expression.DbType.Base<any, any>
               ? Target extends Expression.DbType.Base<any, any>
-                ? BaseFamilyOf<Target> extends ExactKindFamily
+                ? FamilyOfDbType<Target> extends ExactKindFamily
                   ? false
-                  : BaseFamilyOf<Target> extends BaseCastTargetsOf<Source>
+                  : FamilyOfDbType<Target> extends BaseCastTargetsOf<Source>
                     ? true
                     : false
                 : false