effect-qb 0.17.0 → 4.0.0-beta.66

package/src/sqlite/column.ts

@@ -23,7 +23,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>>, {
@@ -48,11 +48,11 @@ const renderNumericDdlType = (
     : `${kind}(${options.precision},${options.scale})`
 }
 
-export const custom = <SchemaType extends Schema.Schema.Any, Db extends Expression.DbType.Any>(
+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,
@@ -64,7 +64,7 @@ export const custom = <SchemaType extends Schema.Schema.Any, Db extends Expressi
     identity: undefined
   })
 
-export const uuid = () => primitive(Schema.UUID, sqliteDatatypes.uuid())
+export const uuid = () => primitive(Schema.String.check(Schema.isUUID()), sqliteDatatypes.uuid())
 export const text = () => primitive(Schema.String, sqliteDatatypes.text())
 export const int = () => primitive(Schema.Int, sqliteDatatypes.int())
 export const number = (options?: BaseColumn.NumericOptions) =>
@@ -84,8 +84,8 @@ export const date = () => primitive(LocalDateStringSchema, sqliteDatatypes.date(
 export const time = () => primitive(LocalTimeStringSchema, sqliteDatatypes.time())
 export const datetime = () => primitive(LocalDateTimeStringSchema, sqliteDatatypes.datetime())
 export const timestamp = () => primitive(LocalDateTimeStringSchema, sqliteDatatypes.timestamp())
-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: { ...sqliteDatatypes.json(), variant: "json" } as Expression.DbType.Json<"sqlite", "json">,
     nullable: false,
     hasDefault: false,

package/src/sqlite/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"
@@ -140,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
         })
       ),
@@ -179,7 +179,7 @@ const sqlClientDriver = (): Driver<any, SqlClient.SqlClient> =>
  * Creates the standard SQLite executor pipeline.
  *
  * By default this uses the built-in SQLite 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/sqlite/function/temporal.ts

@@ -35,7 +35,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,

package/src/sqlite/internal/dsl.ts

@@ -80,10 +80,8 @@ import {
   type TableDialectOf,
   type StatementOfPlan,
   type MutationInputOf,
-  type MutationTargetLike,
   type MutationTargetOfPlan,
   type MergeCapabilities,
-  type MutationTargetInput,
   type MutationValuesInput,
   type SourceDialectOf,
   type SourceLike,
@@ -100,7 +98,6 @@ import {
   type TableLike,
   type UpdateInputOfTarget,
   type MutationTargetNamesOf,
-  type MutationTargetTuple,
   type TupleDependencies,
   type TupleDialect,
   type ResultRow
@@ -138,6 +135,10 @@ import * as ProjectionAlias from "../../internal/projection-alias.js"
 import * as QueryAst from "../../internal/query-ast.js"
 import { normalizeColumnList } from "../../internal/table-options.js"
 
+type MutationTargetLike = Table.AnyTable<Dialect>
+type MutationTargetTuple = readonly [MutationTargetLike, MutationTargetLike, ...MutationTargetLike[]]
+type MutationTargetInput = MutationTargetLike | MutationTargetTuple
+
 /**
  * Dialect-specific DB type profile used to specialize the shared query
  * operator surface.
@@ -1550,11 +1551,11 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
 
   const literalSchemaOf = <Value extends LiteralValue>(
     value: Value
-  ): Schema.Schema.Any | undefined => {
+  ): Schema.Top | undefined => {
     if (value === null || value instanceof Date) {
       return undefined
     }
-    return Schema.Literal(value) as unknown as Schema.Schema.Any
+    return Schema.Literal(value) as unknown as Schema.Top
   }
 
   const literal = <const Value extends LiteralValue>(
@@ -6422,7 +6423,7 @@ type AsCurriedResult<
     target: Target,
     source: Source & (
       SourceRequiredOf<Source> extends never ? unknown : SourceRequirementError<Source>
-    ),
+    ) & SourceDialectConstraint<Source, Dialect>,
     on: On,
     options: MergeOptions<Target, MatchedValues, InsertValues, MatchedPredicate, NotMatchedPredicate>
   ) => QueryPlan<

package/src/sqlite/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,25 +31,15 @@ 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 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,
@@ -169,15 +157,19 @@ export const foreignKey = <
   columns: LocalColumns & BaseTable.NonEmptyColumnInput<LocalColumns>,
   target: () => TargetTable,
   referencedColumns: TargetColumns & BaseTable.NonEmptyColumnInput<TargetColumns> & BaseTable.MatchingColumnArityInput<LocalColumns, TargetColumns>
-): BaseTable.TableOption =>
-  BaseTable.foreignKey<LocalColumns, BaseTable.AnyTable, TargetColumns>(
+) =>
+  BaseTable.foreignKey<LocalColumns, TargetTable, TargetColumns>(
     columns as LocalColumns & BaseTable.NonEmptyColumnInput<LocalColumns>,
-    target as () => BaseTable.AnyTable,
+    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>