effect-qb 0.19.0 → 4.0.0-beta.92

package/src/mysql.ts

@@ -4,11 +4,13 @@ export * as Column from "./mysql/column-extension.js"
 export * as Datatypes from "./mysql/datatypes/index.js"
 /** MySQL error catalog and error normalization helpers. */
 export * as Errors from "./mysql/errors/index.js"
-/** MySQL-specialized JSON expression helpers. */
+/** MySQL-specific JSON expression helpers. Portable JSON helpers are exported from the root package. */
 export * as Json from "./mysql/json.js"
 /** MySQL-specialized typed query execution contracts. */
 export * as Executor from "./mysql/executor.js"
 /** MySQL-specific query helpers. Portable queries are exported from the root package. */
 export * as Query from "./mysql/query-extension.js"
+/** MySQL-only database-type constructors for casts and typed references. */
+export { type as Type } from "./mysql/type.js"
 /** MySQL-specialized built-in renderer entrypoint. */
 export * as Renderer from "./mysql/renderer.js"

package/src/postgres/check.ts

@@ -0,0 +1 @@
+export { noInherit } from "./table.js"

package/src/postgres/column.ts

@@ -23,7 +23,7 @@ import {
 import { postgresDatatypes } from "./datatypes/index.js"
 
 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>>, {
@@ -51,15 +51,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))
 
-const finiteNumber = Schema.Number.pipe(Schema.finite())
+const finiteNumber = Schema.Number.check(Schema.isFinite())
 
-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 Schema.Schema<NonNullable<Schema.Schema.Type<SchemaType>>, any, any>, {
+  makeColumnDefinition(schema as unknown as Schema.Schema<NonNullable<Schema.Schema.Type<SchemaType>>>, {
     dbType: enrichDbType(postgresDatatypes, dbType),
     nullable: false,
     hasDefault: false,
@@ -71,7 +71,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())
@@ -97,7 +97,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())
@@ -129,8 +129,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 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,
@@ -141,8 +141,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 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/datatypes/index.ts

@@ -15,6 +15,7 @@ const withMetadata = <Kind extends keyof typeof postgresDatatypeKinds & string>(
     runtime: kindSpec.runtime,
     compareGroup: familySpec?.compareGroup,
     castTargets: familySpec?.castTargets,
+    implicitTargets: (familySpec as { readonly implicitTargets?: readonly string[] }).implicitTargets,
     traits: familySpec?.traits
   }
 }

package/src/postgres/datatypes/spec.ts

@@ -1,264 +1,10 @@
-import type { DatatypeFamilySpec, DatatypeKindSpec } from "../../internal/datatypes/shape.js"
+import {
+  postgresDatatypeFamilies as matrixPostgresDatatypeFamilies,
+  postgresDatatypeKinds as matrixPostgresDatatypeKinds
+} from "../../internal/datatypes/matrix.js"
 
-export const postgresDatatypeFamilies = {
-  text: {
-    compareGroup: "text",
-    castTargets: [
-      "text",
-      "numeric",
-      "boolean",
-      "date",
-      "time",
-      "timestamp",
-      "interval",
-      "binary",
-      "uuid",
-      "json",
-      "xml",
-      "bit",
-      "oid",
-      "identifier",
-      "network",
-      "spatial",
-      "textsearch",
-      "range",
-      "multirange",
-      "array",
-      "money",
-      "null"
-    ],
-    traits: {
-      textual: true,
-      ordered: true
-    }
-  },
-  numeric: {
-    compareGroup: "numeric",
-    castTargets: ["numeric", "text", "boolean", "date", "time", "timestamp", "interval", "uuid", "bit", "oid", "money"],
-    traits: {
-      ordered: true
-    }
-  },
-  boolean: {
-    compareGroup: "boolean",
-    castTargets: ["boolean", "text", "numeric"],
-    traits: {}
-  },
-  date: {
-    compareGroup: "date",
-    castTargets: ["date", "timestamp", "text"],
-    traits: {
-      ordered: true
-    }
-  },
-  time: {
-    compareGroup: "time",
-    castTargets: ["time", "timestamp", "text"],
-    traits: {
-      ordered: true
-    }
-  },
-  timestamp: {
-    compareGroup: "timestamp",
-    castTargets: ["timestamp", "date", "text"],
-    traits: {
-      ordered: true
-    }
-  },
-  interval: {
-    compareGroup: "interval",
-    castTargets: ["interval", "text"],
-    traits: {
-      ordered: true
-    }
-  },
-  binary: {
-    compareGroup: "binary",
-    castTargets: ["binary", "text"],
-    traits: {}
-  },
-  uuid: {
-    compareGroup: "uuid",
-    castTargets: ["uuid", "text"],
-    traits: {
-      ordered: true
-    }
-  },
-  json: {
-    compareGroup: "json",
-    castTargets: ["json", "text"],
-    traits: {}
-  },
-  xml: {
-    compareGroup: "xml",
-    castTargets: ["xml", "text"],
-    traits: {}
-  },
-  bit: {
-    compareGroup: "bit",
-    castTargets: ["bit", "text", "numeric"],
-    traits: {}
-  },
-  oid: {
-    compareGroup: "oid",
-    castTargets: ["oid", "text", "numeric"],
-    traits: {
-      ordered: true
-    }
-  },
-  identifier: {
-    compareGroup: "identifier",
-    castTargets: ["identifier", "text"],
-    traits: {}
-  },
-  network: {
-    compareGroup: "network",
-    castTargets: ["network", "text"],
-    traits: {}
-  },
-  spatial: {
-    compareGroup: "spatial",
-    castTargets: ["spatial", "text"],
-    traits: {}
-  },
-  textsearch: {
-    compareGroup: "textsearch",
-    castTargets: ["textsearch", "text"],
-    traits: {}
-  },
-  range: {
-    compareGroup: "range",
-    castTargets: ["range", "text"],
-    traits: {}
-  },
-  multirange: {
-    compareGroup: "multirange",
-    castTargets: ["multirange", "text"],
-    traits: {}
-  },
-  enum: {
-    compareGroup: "enum",
-    castTargets: ["enum", "text"],
-    traits: {
-      textual: true,
-      ordered: true
-    }
-  },
-  record: {
-    compareGroup: "record",
-    castTargets: ["record", "text"],
-    traits: {}
-  },
-  array: {
-    compareGroup: "array",
-    castTargets: ["array", "text"],
-    traits: {}
-  },
-  money: {
-    compareGroup: "money",
-    castTargets: ["money", "text", "numeric"],
-    traits: {
-      ordered: true
-    }
-  },
-  null: {
-    compareGroup: "null",
-    castTargets: [
-      "text",
-      "numeric",
-      "boolean",
-      "date",
-      "time",
-      "timestamp",
-      "interval",
-      "binary",
-      "uuid",
-      "json",
-      "xml",
-      "bit",
-      "oid",
-      "identifier",
-      "network",
-      "spatial",
-      "textsearch",
-      "range",
-      "multirange",
-      "array",
-      "money",
-      "null"
-    ],
-    traits: {}
-  }
-} as const satisfies Record<string, DatatypeFamilySpec>
-
-export const postgresDatatypeKinds = {
-  text: { family: "text", runtime: "string" },
-  varchar: { family: "text", runtime: "string" },
-  char: { family: "text", runtime: "string" },
-  citext: { family: "text", runtime: "string" },
-  name: { family: "text", runtime: "string" },
-  uuid: { family: "uuid", runtime: "string" },
-  int2: { family: "numeric", runtime: "number" },
-  int4: { family: "numeric", runtime: "number" },
-  int8: { family: "numeric", runtime: "bigintString" },
-  numeric: { family: "numeric", runtime: "decimalString" },
-  float4: { family: "numeric", runtime: "number" },
-  float8: { family: "numeric", runtime: "number" },
-  money: { family: "money", runtime: "number" },
-  bool: { family: "boolean", runtime: "boolean" },
-  date: { family: "date", runtime: "localDate" },
-  time: { family: "time", runtime: "localTime" },
-  timetz: { family: "time", runtime: "offsetTime" },
-  timestamp: { family: "timestamp", runtime: "localDateTime" },
-  timestamptz: { family: "timestamp", runtime: "instant" },
-  interval: { family: "interval", runtime: "string" },
-  bytea: { family: "binary", runtime: "bytes" },
-  json: { family: "json", runtime: "json" },
-  jsonb: { family: "json", runtime: "json" },
-  xml: { family: "xml", runtime: "string" },
-  bit: { family: "bit", runtime: "string" },
-  varbit: { family: "bit", runtime: "string" },
-  oid: { family: "oid", runtime: "number" },
-  xid: { family: "oid", runtime: "number" },
-  xid8: { family: "oid", runtime: "bigintString" },
-  cid: { family: "oid", runtime: "number" },
-  tid: { family: "identifier", runtime: "string" },
-  regclass: { family: "identifier", runtime: "string" },
-  regtype: { family: "identifier", runtime: "string" },
-  regproc: { family: "identifier", runtime: "string" },
-  regprocedure: { family: "identifier", runtime: "string" },
-  regoper: { family: "identifier", runtime: "string" },
-  regoperator: { family: "identifier", runtime: "string" },
-  regconfig: { family: "identifier", runtime: "string" },
-  regdictionary: { family: "identifier", runtime: "string" },
-  pg_lsn: { family: "identifier", runtime: "string" },
-  txid_snapshot: { family: "identifier", runtime: "string" },
-  inet: { family: "network", runtime: "string" },
-  cidr: { family: "network", runtime: "string" },
-  macaddr: { family: "network", runtime: "string" },
-  macaddr8: { family: "network", runtime: "string" },
-  point: { family: "spatial", runtime: "unknown" },
-  line: { family: "spatial", runtime: "unknown" },
-  lseg: { family: "spatial", runtime: "unknown" },
-  box: { family: "spatial", runtime: "unknown" },
-  path: { family: "spatial", runtime: "unknown" },
-  polygon: { family: "spatial", runtime: "unknown" },
-  circle: { family: "spatial", runtime: "unknown" },
-  tsvector: { family: "textsearch", runtime: "string" },
-  tsquery: { family: "textsearch", runtime: "string" },
-  int4range: { family: "range", runtime: "unknown" },
-  int8range: { family: "range", runtime: "unknown" },
-  numrange: { family: "range", runtime: "unknown" },
-  tsrange: { family: "range", runtime: "unknown" },
-  tstzrange: { family: "range", runtime: "unknown" },
-  daterange: { family: "range", runtime: "unknown" },
-  int4multirange: { family: "multirange", runtime: "unknown" },
-  int8multirange: { family: "multirange", runtime: "unknown" },
-  nummultirange: { family: "multirange", runtime: "unknown" },
-  tsmultirange: { family: "multirange", runtime: "unknown" },
-  tstzmultirange: { family: "multirange", runtime: "unknown" },
-  datemultirange: { family: "multirange", runtime: "unknown" }
-} as const satisfies Record<string, DatatypeKindSpec>
+export const postgresDatatypeFamilies = matrixPostgresDatatypeFamilies
+export const postgresDatatypeKinds = matrixPostgresDatatypeKinds
 
 export type PostgresDatatypeFamily = keyof typeof postgresDatatypeFamilies
 export type PostgresDatatypeKind = keyof typeof postgresDatatypeKinds

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"
@@ -41,8 +41,6 @@ export type PostgresQueryError<PlanValue extends CoreQuery.QueryPlan<any, any, a
 
 /** Runs an effect within the ambient Postgres SQL transaction service. */
 export const withTransaction = CoreExecutor.withTransaction
-/** Runs an effect in a nested Postgres SQL transaction scope. */
-export const withSavepoint = CoreExecutor.withSavepoint
 
 /** Postgres executor whose error channel narrows based on the query plan. */
 export interface QueryExecutor<Context = never> {
@@ -142,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
         })
       ),
@@ -175,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/foreign-key.ts

@@ -0,0 +1,24 @@
+import * as BaseTable from "../internal/table.js"
+import type { TableOptionSpec } from "../internal/table-options.js"
+
+type ForeignKeySpec = Extract<TableOptionSpec, { readonly kind: "foreignKey" }>
+
+export const deferrable = <Spec extends ForeignKeySpec, TableContext extends BaseTable.TableDefinition<any, any, any, "schema", any>>(
+  option: BaseTable.TableOption<Spec, TableContext>
+): BaseTable.TableOption<Spec & { readonly deferrable: true }, TableContext> =>
+  BaseTable.mapOption(option, (spec) => ({
+    ...spec,
+    deferrable: true
+  } as Spec & { readonly deferrable: true }))
+
+export const initiallyDeferred = <Spec extends ForeignKeySpec, TableContext extends BaseTable.TableDefinition<any, any, any, "schema", any>>(
+  option: BaseTable.TableOption<Spec, TableContext>
+): BaseTable.TableOption<Spec & {
+  readonly deferrable: true
+  readonly initiallyDeferred: true
+}, TableContext> =>
+  BaseTable.mapOption(option, (spec) => ({
+    ...spec,
+    deferrable: true,
+    initiallyDeferred: true
+  } as Spec & { readonly deferrable: true; readonly initiallyDeferred: true }))

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,

package/src/postgres/index.ts

@@ -0,0 +1 @@
+export { include, key, keys, uniqueIndex, using, where } from "./table.js"