effect-qb 0.13.0 → 0.14.0

package/src/internal/table.ts

@@ -3,14 +3,17 @@ import * as Schema from "effect/Schema"
 
 import * as Plan from "./plan.js"
 import type { Any as AnyExpression } from "./expression.js"
+import type { TrueFormula } from "./predicate-formula.js"
 import type { BoundColumnFrom } from "./column-state.js"
 import { bindColumn, type AnyColumnDefinition } from "./column-state.js"
 import {
   collectInlineOptions,
   normalizeColumnList,
   resolvePrimaryKeyColumns,
-  type DeclaredTableOptions as InternalDeclaredTableOptions,
+  type DdlExpressionLike,
+  type IndexKeySpec,
   type NormalizeColumns,
+  type ReferentialAction,
   type TableOptionSpec,
   type ValidateKnownColumns,
   type ValidatePrimaryKeyColumns,
@@ -42,7 +45,16 @@ type TableDialect<Fields extends TableFieldMap> = Fields[keyof Fields][typeof im
 type TableKind = "schema" | "alias"
 type DefaultSchemaName = "public"
 type ClassOptionSpec = Exclude<TableOptionSpec, { readonly kind: "primaryKey" }>
-type ClassTableOption = TableOption<ClassOptionSpec>
+interface TableOptionBuilderLike<
+  Spec extends TableOptionSpec = TableOptionSpec
+> {
+  (
+    table: TableDefinition<any, any, any, "schema", any>
+  ): TableDefinition<any, any, any, "schema", any>
+  readonly option: Spec
+}
+
+type ClassTableOption = TableOptionBuilderLike<ClassOptionSpec>
 type ClassDeclaredTableOptions = readonly ClassTableOption[]
 
 type BuildPrimaryKey<
@@ -83,12 +95,13 @@ export type BoundColumns<
 
 /** Derived runtime schemas exposed by a table definition. */
 export interface TableSchemas<
+  Name extends string,
   Fields extends TableFieldMap,
   PrimaryKeyColumns extends keyof Fields & string
 > {
-  readonly select: Schema.Schema<SelectRow<Fields>>
-  readonly insert: Schema.Schema<InsertRow<Fields>>
-  readonly update: Schema.Schema<UpdateRow<Fields, PrimaryKeyColumns>>
+  readonly select: Schema.Schema<SelectRow<Name, Fields>>
+  readonly insert: Schema.Schema<InsertRow<Name, Fields>>
+  readonly update: Schema.Schema<UpdateRow<Name, Fields, PrimaryKeyColumns>>
 }
 
 interface TableState<
@@ -116,11 +129,12 @@ export interface TableSchemaNamespace<SchemaName extends string> {
   >(
     name: Name,
     fields: Fields,
-    ...options: InternalDeclaredTableOptions
+    ...options: DeclaredTableOptions
   ) => TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", SchemaName>
 }
 
-export type DeclaredTableOptions = InternalDeclaredTableOptions
+export type DeclaredTableOptions = readonly TableOptionBuilderLike[]
+export type { DdlExpressionLike, IndexKeySpec, NormalizeColumns, ReferentialAction } from "./table-options.js"
 
 export type TableDefinition<
   Name extends string,
@@ -131,12 +145,12 @@ export type TableDefinition<
 > = Pipeable & {
   readonly name: Name
   readonly columns: BoundColumns<Name, Fields>
-  readonly schemas: TableSchemas<Fields, PrimaryKeyColumns>
+  readonly schemas: TableSchemas<Name, Fields, PrimaryKeyColumns>
   readonly [TypeId]: TableState<Name, Fields, PrimaryKeyColumns, Kind, SchemaName>
   readonly [Plan.TypeId]: Plan.State<
     BoundColumns<Name, Fields>,
     never,
-    Record<Name, Plan.Source<Name>>,
+    Record<Name, Plan.Source<Name, "required", TrueFormula>>,
     TableDialect<Fields>
   >
   readonly [OptionsSymbol]: readonly TableOptionSpec[]
@@ -144,7 +158,7 @@ export type TableDefinition<
 } & BoundColumns<Name, Fields> & Plan.Plan<
     BoundColumns<Name, Fields>,
     never,
-    Record<Name, Plan.Source<Name>>,
+    Record<Name, Plan.Source<Name, "required", TrueFormula>>,
     TableDialect<Fields>
   >
 
@@ -161,12 +175,12 @@ export type TableClassStatic<
   SchemaName extends string | undefined = DefaultSchemaName
 > = (abstract new (...args: any[]) => any) & Pipeable & {
   readonly columns: BoundColumns<Name, Fields>
-  readonly schemas: TableSchemas<Fields, PrimaryKeyColumns>
+  readonly schemas: TableSchemas<Name, Fields, PrimaryKeyColumns>
   readonly [TypeId]: TableState<Name, Fields, PrimaryKeyColumns, "schema", SchemaName>
   readonly [Plan.TypeId]: Plan.State<
     BoundColumns<Name, Fields>,
     never,
-    Record<Name, Plan.Source<Name>>,
+    Record<Name, Plan.Source<Name, "required", TrueFormula>>,
     TableDialect<Fields>
   >
   readonly [OptionsSymbol]: readonly TableOptionSpec[]
@@ -176,7 +190,7 @@ export type TableClassStatic<
 } & BoundColumns<Name, Fields> & Plan.Plan<
     BoundColumns<Name, Fields>,
     never,
-    Record<Name, Plan.Source<Name>>,
+    Record<Name, Plan.Source<Name, "required", TrueFormula>>,
     TableDialect<Fields>
   >
 
@@ -209,7 +223,7 @@ type BuildArtifacts<
   PrimaryKeyColumns extends keyof Fields & string
 > = {
   readonly columns: BoundColumns<Name, Fields>
-  readonly schemas: TableSchemas<Fields, PrimaryKeyColumns>
+  readonly schemas: TableSchemas<Name, Fields, PrimaryKeyColumns>
   readonly normalizedOptions: readonly TableOptionSpec[]
   readonly primaryKey: readonly PrimaryKeyColumns[]
 }
@@ -231,7 +245,7 @@ const buildArtifacts = <
   const columns = Object.fromEntries(
     Object.entries(fields).map(([key, column]) => [key, bindColumn(name, key, column, name, schemaName)])
   ) as BoundColumns<Name, Fields>
-  const schemas = deriveSchemas(fields, primaryKey)
+  const schemas = deriveSchemas(name, fields, primaryKey)
   return {
     columns,
     schemas,
@@ -299,6 +313,21 @@ const extractDeclaredOptions = (
   declaredOptions: DeclaredTableOptions | undefined
 ): readonly TableOptionSpec[] => declaredOptions?.map((option) => option.option) ?? []
 
+const applyDeclaredOptions = <
+  Table extends TableDefinition<any, any, any, "schema", any>
+>(
+  table: Table,
+  declaredOptions: DeclaredTableOptions | undefined
+): Table => {
+  if (declaredOptions === undefined || declaredOptions.length === 0) {
+    return table
+  }
+  return declaredOptions.reduce<TableDefinition<any, any, any, "schema", any>>(
+    (current, option) => option(current),
+    table
+  ) as unknown as Table
+}
+
 const validateClassOptions = (declaredOptions: readonly TableOptionSpec[]): void => {
   for (const option of declaredOptions) {
     if (option.kind === "primaryKey") {
@@ -340,14 +369,26 @@ const ensureClassArtifacts = <
     return cached
   }
   const state = self[TypeId]
-  const declaredOptions = extractDeclaredOptions(self[options])
-  validateClassOptions(declaredOptions)
-  const artifacts = buildArtifacts(
-    state.name,
-    state.fields,
-    declaredOptions,
-    state.schemaName
-  ) as BuildArtifacts<Name, Fields, PrimaryKeyColumns>
+  const classOptions = self[options]
+  validateClassOptions(extractDeclaredOptions(classOptions))
+  const table = applyDeclaredOptions(
+    makeTable(
+      state.name,
+      state.fields,
+      [],
+      state.name,
+      "schema",
+      state.schemaName,
+      state.schemaName === undefined || state.schemaName === "public" ? "default" : "explicit"
+    ) as TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", typeof state.schemaName>,
+    classOptions
+  )
+  const artifacts = {
+    columns: table.columns,
+    schemas: table.schemas,
+    normalizedOptions: table[OptionsSymbol],
+    primaryKey: table[TypeId].primaryKey as readonly PrimaryKeyColumns[]
+  } satisfies BuildArtifacts<Name, Fields, PrimaryKeyColumns>
   Object.defineProperty(self, CacheSymbol, {
     configurable: true,
     value: artifacts
@@ -384,6 +425,25 @@ const makeOption = <Spec extends TableOptionSpec>(option: Spec): TableOption<Spe
   return builder
 }
 
+const makeResolvedOption = <Spec extends TableOptionSpec>(
+  option: Spec,
+  resolve: (table: TableDefinition<any, any, any, "schema", any>) => Spec
+): TableOption<Spec> => {
+  const builder = ((table: TableDefinition<any, any, any, "schema", any>) =>
+    appendOption(table, resolve(table))) as unknown as TableOption<Spec>
+  ;(builder as { option: Spec }).option = option
+  return builder
+}
+
+export const option = <Spec extends TableOptionSpec>(spec: Spec): TableOption<Spec> =>
+  makeOption(spec)
+
+export const optionFromTable = <Spec extends TableOptionSpec>(
+  spec: Spec,
+  resolve: (table: TableDefinition<any, any, any, "schema", any>) => Spec
+): TableOption<Spec> =>
+  makeResolvedOption(spec, resolve)
+
 /** Creates a table definition from a name and field map. */
 export function make<
   Name extends string,
@@ -422,17 +482,20 @@ export const schema = <SchemaName extends string>(
   >(
     name: Name,
     fields: Fields,
-    ...options: InternalDeclaredTableOptions
+    ...options: DeclaredTableOptions
   ): TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", SchemaName> =>
-    makeTable(
-      name,
-      fields,
-      extractDeclaredOptions(options),
-      name,
-      "schema",
-      schemaName,
-      "explicit"
-    ) as TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", SchemaName>
+    applyDeclaredOptions(
+      makeTable(
+        name,
+        fields,
+        [],
+        name,
+        "schema",
+        schemaName,
+        "explicit"
+      ) as TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", SchemaName>,
+      options
+    )
 })
 
 /**
@@ -465,7 +528,7 @@ export const alias = <
   const aliased = Object.create(TableProto)
   aliased.name = aliasName
   aliased.columns = columns
-  aliased.schemas = table.schemas
+  aliased.schemas = deriveSchemas(aliasName, state.fields, state.primaryKey)
   aliased[TypeId] = {
     name: aliasName,
     baseName: state.baseName,
@@ -581,7 +644,7 @@ export function Class<
 
 /** Declares a table-level primary key. */
 export const primaryKey = <
-  Columns extends string | readonly string[]
+  const Columns extends string | readonly string[]
 >(
   columns: Columns
 ): TableOption<{
@@ -594,7 +657,7 @@ export const primaryKey = <
 
 /** Declares a table-level unique constraint. */
 export const unique = <
-  Columns extends string | readonly string[]
+  const Columns extends string | readonly string[]
 >(
   columns: Columns
 ): TableOption<{
@@ -607,7 +670,7 @@ export const unique = <
 
 /** Declares a table-level index. */
 export const index = <
-  Columns extends string | readonly string[]
+  const Columns extends string | readonly string[]
 >(
   columns: Columns
 ): TableOption<{
@@ -620,9 +683,9 @@ export const index = <
 
 /** Declares a table-level foreign key. */
 export const foreignKey = <
-  LocalColumns extends string | readonly string[],
+  const LocalColumns extends string | readonly string[],
   TargetTable extends AnyTable,
-  TargetColumns extends string | readonly string[]
+  const TargetColumns extends string | readonly string[]
 >(
   columns: LocalColumns,
   target: () => TargetTable,
@@ -650,11 +713,11 @@ export const foreignKey = <
 /** Declares a check constraint expression. */
 export const check = <Name extends string>(
   name: Name,
-  predicate: AnyExpression
+  predicate: DdlExpressionLike
 ): TableOption<{
   readonly kind: "check"
   readonly name: Name
-  readonly predicate: AnyExpression
+  readonly predicate: DdlExpressionLike
 }> => makeOption({
   kind: "check",
   name,

package/src/mysql/column.ts

@@ -19,6 +19,7 @@ export const json = BaseColumn.mysql.json
 export const custom = BaseColumn.mysql.custom
 
 export const nullable = BaseColumn.nullable
+export const brand = BaseColumn.brand
 export const primaryKey = BaseColumn.primaryKey
 export const unique = BaseColumn.unique
 const default_ = BaseColumn.default_

package/src/mysql/datatypes/index.ts

@@ -1,6 +1,21 @@
-import { makeDatatypeModule } from "../../internal/datatypes/define.js"
+import type { DatatypeModule } from "../../internal/datatypes/define.js"
+import type * as Expression from "../../internal/expression.js"
 import { mysqlDatatypeKinds } from "./spec.js"
 
-export const mysqlDatatypes = makeDatatypeModule("mysql", mysqlDatatypeKinds)
+const mysqlDatatypeModule = {
+  custom: (kind: string) => ({
+    dialect: "mysql",
+    kind
+  })
+} as Record<string, (...args: readonly any[]) => Expression.DbType.Base<"mysql", string>>
+
+for (const kind of Object.keys(mysqlDatatypeKinds)) {
+  mysqlDatatypeModule[kind] = () => ({
+    dialect: "mysql",
+    kind
+  })
+}
+
+export const mysqlDatatypes = mysqlDatatypeModule as DatatypeModule<"mysql", typeof mysqlDatatypeKinds>
 
 export type MysqlDatatypeModule = typeof mysqlDatatypes

package/src/mysql/function/core.ts

@@ -2,3 +2,4 @@ import { mysqlQuery } from "../private/query.js"
 
 /** MySQL scalar core functions. */
 export const coalesce = mysqlQuery.coalesce
+export const call = mysqlQuery.call

package/src/mysql/function/index.ts

@@ -6,6 +6,7 @@ export { json } from "./json.js"
 export * as temporal from "./temporal.js"
 
 export { coalesce } from "./core.js"
+export { call } from "./core.js"
 export { lower, upper, concat } from "./string.js"
 export { count, max, min } from "./aggregate.js"
 export { over, rowNumber, rank, denseRank } from "./window.js"

package/src/mysql/private/query.ts

@@ -1,13 +1 @@
-import * as Expression from "../../internal/expression.js"
-import { makeDialectQuery } from "../../internal/query-factory.js"
-import { mysqlDatatypes } from "../datatypes/index.js"
-
-export const mysqlQuery = makeDialectQuery({
-  dialect: "mysql",
-  textDb: { dialect: "mysql", kind: "text" } as Expression.DbType.MySqlText,
-  numericDb: { dialect: "mysql", kind: "double" } as Expression.DbType.MySqlDouble,
-  boolDb: { dialect: "mysql", kind: "boolean" } as Expression.DbType.MySqlBool,
-  timestampDb: { dialect: "mysql", kind: "timestamp" } as Expression.DbType.MySqlTimestamp,
-  nullDb: { dialect: "mysql", kind: "null" } as Expression.DbType.Base<"mysql", "null">,
-  type: mysqlDatatypes
-})
+export { mysqlQuery } from "../../internal/mysql-query.js"

package/src/mysql/query.ts

@@ -38,6 +38,7 @@ import {
 import { mysqlQuery } from "./private/query.js"
 
 export const literal = mysqlQuery.literal
+export const column = mysqlQuery.column
 export const cast = mysqlQuery.cast
 export const type = mysqlQuery.type
 export const eq = mysqlQuery.eq
@@ -50,6 +51,10 @@ export const isNull = mysqlQuery.isNull
 export const isNotNull = mysqlQuery.isNotNull
 export const like = mysqlQuery.like
 export const ilike = mysqlQuery.ilike
+export const regexMatch = mysqlQuery.regexMatch
+export const regexIMatch = mysqlQuery.regexIMatch
+export const regexNotMatch = mysqlQuery.regexNotMatch
+export const regexNotIMatch = mysqlQuery.regexNotIMatch
 export const and = mysqlQuery.and
 export const or = mysqlQuery.or
 export const not = mysqlQuery.not

package/src/postgres/cast.ts

@@ -0,0 +1,31 @@
+import type * as Expression from "../internal/expression.js"
+import { postgresQuery } from "./private/query.js"
+
+type CastInput = Parameters<typeof postgresQuery.cast>[0]
+type CastTarget = Parameters<typeof postgresQuery.cast>[1]
+type CastExpression<Target extends CastTarget> = Expression.Expression<
+  Expression.RuntimeOfDbType<Target>,
+  Target,
+  Expression.Nullability,
+  string,
+  Expression.AggregationKind,
+  any,
+  Expression.SourceDependencies,
+  Expression.SourceNullabilityMode
+>
+
+const to: {
+  <Value extends CastInput, Target extends CastTarget>(
+    value: Value,
+    target: Target
+  ): CastExpression<Target>
+  <Target extends CastTarget>(
+    target: Target
+  ): <Value extends CastInput>(value: Value) => CastExpression<Target>
+} = ((...args: [CastInput, CastTarget] | [CastTarget]) =>
+  args.length === 1
+    ? ((value: CastInput) => postgresQuery.cast(value as never, args[0] as never))
+    : postgresQuery.cast(args[0] as never, args[1] as never)) as unknown as typeof to
+
+/** Postgres cast helpers. */
+export const cast = { to }

package/src/postgres/column.ts

@@ -1,11 +1,37 @@
 export {
+  brand,
+  ddlType,
+  int2,
   boolean,
   date,
   default_ as default,
+  int8,
+  float4,
+  float8,
   generated,
+  array,
+  identityAlways,
+  identityByDefault,
+  foreignKey,
+  index,
   int,
+  char,
+  varchar,
   json,
+  jsonb,
   nullable,
+  time,
+  timetz,
+  timestamptz,
+  interval,
+  bytea,
+  name,
+  oid,
+  regclass,
+  bit,
+  varbit,
+  xml,
+  pg_lsn,
   number,
   primaryKey,
   references,

package/src/postgres/datatypes/index.ts

@@ -1,8 +1,43 @@
-import { makeDatatypeModule } from "../../internal/datatypes/define.js"
-import { postgresDatatypeKinds } from "./spec.js"
+import type { DatatypeModule } from "../../internal/datatypes/define.js"
+import type * as Expression from "../../internal/expression.js"
+import { postgresDatatypeFamilies, postgresDatatypeKinds } from "./spec.js"
 
-export const postgresDatatypes = makeDatatypeModule("postgres", postgresDatatypeKinds, {
-  boolean: "bool"
-})
+const postgresDatatypeModule = {
+  custom: (kind: string) => ({
+    dialect: "postgres",
+    kind
+  }),
+  boolean: () => ({
+    dialect: "postgres",
+    kind: "bool"
+  })
+} as Record<string, (...args: readonly any[]) => Expression.DbType.Base<"postgres", string>>
+
+for (const kind of Object.keys(postgresDatatypeKinds)) {
+  postgresDatatypeModule[kind] = () => ({
+    dialect: "postgres",
+    kind
+  })
+}
+
+export const postgresDatatypes = {
+  ...(postgresDatatypeModule as DatatypeModule<
+    "postgres",
+    typeof postgresDatatypeKinds,
+    { readonly boolean: "bool" }
+  >),
+  json: (): Expression.DbType.Json<"postgres", "json"> => ({
+    dialect: "postgres",
+    kind: "json",
+    variant: "json"
+  }),
+  jsonb: (): Expression.DbType.Json<"postgres", "jsonb"> => ({
+    dialect: "postgres",
+    kind: "jsonb",
+    variant: "jsonb"
+  })
+}
+
+export { postgresDatatypeFamilies, postgresDatatypeKinds }
 
 export type PostgresDatatypeModule = typeof postgresDatatypes

package/src/postgres/function/core.ts

@@ -1,4 +1,16 @@
+import type { ExpressionInput } from "../query.js"
 import { postgresQuery } from "../private/query.js"
+import { isSequenceDefinition, type SequenceDefinition } from "../schema-management.js"
 
 /** Postgres scalar core functions. */
 export const coalesce = postgresQuery.coalesce
+export const call = postgresQuery.call
+export const uuidGenerateV4 = postgresQuery.uuidGenerateV4
+export const nextVal = (
+  value: ExpressionInput | SequenceDefinition<string, string | undefined>
+) =>
+  postgresQuery.nextVal(
+    isSequenceDefinition(value)
+      ? postgresQuery.cast(postgresQuery.literal(value.qualifiedName()), postgresQuery.type.regclass())
+      : value
+  )

package/src/postgres/function/index.ts

@@ -2,10 +2,11 @@ export * as core from "./core.js"
 export * as string from "./string.js"
 export * as aggregate from "./aggregate.js"
 export * as window from "./window.js"
-export { json } from "./json.js"
+export { json, jsonb } from "./json.js"
 export * as temporal from "./temporal.js"
 
 export { coalesce } from "./core.js"
+export { call, uuidGenerateV4, nextVal } from "./core.js"
 export { lower, upper, concat } from "./string.js"
 export { count, max, min } from "./aggregate.js"
 export { over, rowNumber, rank, denseRank } from "./window.js"