effect-qb 0.13.0 → 0.15.0

package/src/postgres/query.ts

@@ -1,5 +1,7 @@
-import { postgresQuery } from "./private/query.js"
 import {
+  type AnyTableFunctionSource,
+  type AnyUnnestSource,
+  type AnyValuesSource,
   type CapabilitiesOfPlan,
   type CompletePlan,
   type DialectCompatiblePlan,
@@ -36,92 +38,117 @@ import {
   type StatementOfPlan,
   type StringExpressionInput
 } from "../internal/query.js"
+import {
+  type PublicNonStructuredFromApi,
+  type PublicGenerateSeriesApi,
+  type PublicStructuredFromConstraint,
+  type PublicStructuredFromResult,
+  type as postgresType,
+  values,
+  unnest,
+  select,
+  insert,
+  generateSeries as dslGenerateSeries,
+  from as dslFrom
+} from "./internal/dsl.js"
+
+export {
+  literal,
+  column,
+  eq,
+  neq,
+  lt,
+  lte,
+  gt,
+  gte,
+  isNull,
+  isNotNull,
+  like,
+  ilike,
+  collate,
+  regexMatch,
+  regexIMatch,
+  regexNotMatch,
+  regexNotIMatch,
+  and,
+  or,
+  not,
+  all,
+  any,
+  case_ as case,
+  match,
+  in_ as in,
+  notIn,
+  between,
+  contains,
+  containedBy,
+  overlaps,
+  exists,
+  isDistinctFrom,
+  isNotDistinctFrom,
+  excluded,
+  as,
+  with_ as with,
+  withRecursive,
+  lateral,
+  scalar,
+  inSubquery,
+  compareAny,
+  compareAll,
+  values,
+  unnest,
+  select,
+  returning,
+  onConflict,
+  insert,
+  update,
+  upsert,
+  delete_ as delete,
+  truncate,
+  merge,
+  transaction,
+  commit,
+  rollback,
+  savepoint,
+  rollbackTo,
+  releaseSavepoint,
+  createTable,
+  dropTable,
+  createIndex,
+  dropIndex,
+  union,
+  unionAll,
+  intersect,
+  intersectAll,
+  except,
+  exceptAll,
+  where,
+  having,
+  innerJoin,
+  leftJoin,
+  rightJoin,
+  fullJoin,
+  crossJoin,
+  distinct,
+  distinctOn,
+  limit,
+  offset,
+  lock,
+  orderBy,
+  groupBy
+} from "./internal/dsl.js"
+export { postgresType as type }
+export const generateSeries: PublicGenerateSeriesApi = dslGenerateSeries as PublicGenerateSeriesApi
+
+type StructuredSource = AnyValuesSource | AnyUnnestSource | AnyTableFunctionSource
+
+type StructuredFromApi = <CurrentSource extends StructuredSource>(
+  source: CurrentSource
+) => <PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>>(
+  plan: PlanValue & PublicStructuredFromConstraint<PlanValue, CurrentSource, "postgres">
+) => PublicStructuredFromResult<PlanValue, CurrentSource, "postgres">
 
-export const literal = postgresQuery.literal
-export const cast = postgresQuery.cast
-export const type = postgresQuery.type
-export const eq = postgresQuery.eq
-export const neq = postgresQuery.neq
-export const lt = postgresQuery.lt
-export const lte = postgresQuery.lte
-export const gt = postgresQuery.gt
-export const gte = postgresQuery.gte
-export const isNull = postgresQuery.isNull
-export const isNotNull = postgresQuery.isNotNull
-export const like = postgresQuery.like
-export const ilike = postgresQuery.ilike
-export const and = postgresQuery.and
-export const or = postgresQuery.or
-export const not = postgresQuery.not
-export const all = postgresQuery.all
-export const any = postgresQuery.any
-const case_ = postgresQuery.case
-export const match = postgresQuery.match
-export const in_ = postgresQuery.in
-export const notIn = postgresQuery.notIn
-export const between = postgresQuery.between
-export const contains = postgresQuery.contains
-export const containedBy = postgresQuery.containedBy
-export const overlaps = postgresQuery.overlaps
-export const exists = postgresQuery.exists
-export const isDistinctFrom = postgresQuery.isDistinctFrom
-export const isNotDistinctFrom = postgresQuery.isNotDistinctFrom
-export const excluded = postgresQuery.excluded
-export const as = postgresQuery.as
-export const with_ = postgresQuery.with
-export const withRecursive = postgresQuery.withRecursive
-export const lateral = postgresQuery.lateral
-export const scalar = postgresQuery.scalar
-export const inSubquery = postgresQuery.inSubquery
-export const compareAny = postgresQuery.compareAny
-export const compareAll = postgresQuery.compareAll
-export const values = postgresQuery.values
-export const unnest = postgresQuery.unnest
-export const generateSeries = postgresQuery.generateSeries
-export const returning = postgresQuery.returning
-export const onConflict = postgresQuery.onConflict
-export const insert = postgresQuery.insert
-export const update = postgresQuery.update
-export const upsert = postgresQuery.upsert
-export const delete_ = postgresQuery.delete
-export const truncate = postgresQuery.truncate
-export const merge = postgresQuery.merge
-export const transaction = postgresQuery.transaction
-export const commit = postgresQuery.commit
-export const rollback = postgresQuery.rollback
-export const savepoint = postgresQuery.savepoint
-export const rollbackTo = postgresQuery.rollbackTo
-export const releaseSavepoint = postgresQuery.releaseSavepoint
-export const createTable = postgresQuery.createTable
-export const dropTable = postgresQuery.dropTable
-export const createIndex = postgresQuery.createIndex
-export const dropIndex = postgresQuery.dropIndex
-export const union = postgresQuery.union
-export const unionAll = postgresQuery.unionAll
-export const intersect = postgresQuery.intersect
-export const intersectAll = postgresQuery.intersectAll
-export const except = postgresQuery.except
-export const exceptAll = postgresQuery.exceptAll
-export const select = postgresQuery.select
-export const where = postgresQuery.where
-export const having = postgresQuery.having
-export const from = postgresQuery.from
-export const innerJoin = postgresQuery.innerJoin
-export const leftJoin = postgresQuery.leftJoin
-export const rightJoin = postgresQuery.rightJoin
-export const fullJoin = postgresQuery.fullJoin
-export const crossJoin = postgresQuery.crossJoin
-export const distinct = postgresQuery.distinct
-export const distinctOn = postgresQuery.distinctOn
-export const limit = postgresQuery.limit
-export const offset = postgresQuery.offset
-export const lock = postgresQuery.lock
-export const orderBy = postgresQuery.orderBy
-export const groupBy = postgresQuery.groupBy
-export { case_ as case }
-export { in_ as in }
-export { with_ as with }
-export { delete_ as delete }
+export const from: StructuredFromApi & PublicNonStructuredFromApi = dslFrom as StructuredFromApi & PublicNonStructuredFromApi
 
 export type {
   CapabilitiesOfPlan,

package/src/postgres/renderer.ts

@@ -1,4 +1,5 @@
 import * as CoreRenderer from "../internal/renderer.js"
+import { renderPostgresPlan } from "./internal/renderer.js"
 
 /** Postgres-specialized rendered query shape. */
 export type RenderedQuery<Row> = CoreRenderer.RenderedQuery<Row, "postgres">
@@ -11,19 +12,8 @@ export { TypeId } from "../internal/renderer.js"
 export type { Projection } from "../internal/renderer.js"
 
 /** Creates the built-in Postgres renderer. */
-export function make(): Renderer
-export function make(dialect: "postgres"): Renderer
-export function make(
-  dialect: "postgres",
-  render: Parameters<typeof CoreRenderer.make>[1]
-): Renderer
-export function make(
-  dialectOrRender?: "postgres" | Parameters<typeof CoreRenderer.make>[1],
-  render?: Parameters<typeof CoreRenderer.make>[1]
-): Renderer {
-  const customRender = typeof dialectOrRender === "function" ? dialectOrRender : render
-  return customRender ? CoreRenderer.make("postgres", customRender as any) : CoreRenderer.make("postgres")
-}
+export const make = (): Renderer =>
+  CoreRenderer.make("postgres", renderPostgresPlan)
 
 /** Shared built-in Postgres renderer instance. */
 export const postgres = make()

package/src/postgres/schema-expression.ts

@@ -0,0 +1,17 @@
+export {
+  TypeId,
+  fromAst,
+  fromSql,
+  isSchemaExpression,
+  normalize,
+  parseExpression,
+  render,
+  toAst,
+  type Any,
+  type SchemaExpression
+} from "../internal/schema-expression.js"
+
+export {
+  normalizeDdlExpressionSql,
+  renderDdlExpressionSql
+} from "./internal/schema-ddl.js"

package/src/postgres/schema-management.ts

@@ -0,0 +1,204 @@
+import * as Schema from "effect/Schema"
+import { pipeArguments, type Pipeable } from "effect/Pipeable"
+
+import type * as Expression from "../internal/scalar.js"
+import { makeColumnDefinition, type ColumnDefinition } from "../internal/column-state.js"
+
+export const EnumTypeId: unique symbol = Symbol.for("effect-qb/SchemaManagement/Enum")
+export const SequenceTypeId: unique symbol = Symbol.for("effect-qb/SchemaManagement/Sequence")
+
+type QualifiedName<
+  Name extends string,
+  SchemaName extends string | undefined
+> = SchemaName extends string
+  ? SchemaName extends "public"
+    ? Name
+    : `${SchemaName}.${Name}`
+  : Name
+
+type EnumColumn<
+  Name extends string,
+  Values extends readonly [string, ...string[]],
+  SchemaName extends string | undefined
+> = ColumnDefinition<
+  Values[number],
+  Values[number],
+  Values[number],
+  Expression.DbType.Enum<"postgres", QualifiedName<Name, SchemaName>>,
+  false,
+  false,
+  false,
+  false,
+  false,
+  undefined
+>
+
+const EnumProto = {
+  pipe(this: unknown) {
+    return pipeArguments(this, arguments)
+  },
+  qualifiedName(this: EnumDefinition) {
+    return this.schemaName === undefined || this.schemaName === "public"
+      ? this.name
+      : `${this.schemaName}.${this.name}`
+  },
+  type(this: EnumDefinition) {
+    return {
+      dialect: "postgres",
+      kind: this.qualifiedName(),
+      variant: "enum"
+    }
+  },
+  column(this: EnumDefinition) {
+    const values = this.values.map((value) => Schema.Literal(value)) as unknown as readonly [Schema.Schema.Any, ...Schema.Schema.Any[]]
+    return makeColumnDefinition(
+      values.length === 1 ? values[0]! : Schema.Union(...values),
+      {
+        dbType: this.type(),
+        nullable: false,
+        hasDefault: false,
+        generated: false,
+        primaryKey: false,
+        unique: false,
+        references: undefined,
+        ddlType: this.qualifiedName(),
+        identity: undefined,
+        enum: {
+          name: this.name,
+          schemaName: this.schemaName,
+          values: this.values
+        }
+      }
+    )
+  }
+}
+
+const SequenceProto = {
+  pipe(this: unknown) {
+    return pipeArguments(this, arguments)
+  },
+  qualifiedName(this: SequenceDefinition) {
+    return this.schemaName === undefined || this.schemaName === "public"
+      ? this.name
+      : `${this.schemaName}.${this.name}`
+  }
+}
+
+export interface EnumDefinition<
+  Name extends string = string,
+  Values extends readonly [string, ...string[]] = readonly [string, ...string[]],
+  SchemaName extends string | undefined = undefined
+> extends Pipeable {
+  readonly name: Name
+  readonly values: Values
+  readonly schemaName: SchemaName
+  readonly [EnumTypeId]: {
+    readonly kind: "enum"
+    readonly name: Name
+    readonly values: Values
+    readonly schemaName: SchemaName
+  }
+  readonly qualifiedName: () => QualifiedName<Name, SchemaName>
+  readonly type: () => Expression.DbType.Enum<"postgres", QualifiedName<Name, SchemaName>>
+  readonly column: () => EnumColumn<Name, Values, SchemaName>
+}
+
+export interface SequenceDefinition<
+  Name extends string = string,
+  SchemaName extends string | undefined = undefined
+> extends Pipeable {
+  readonly name: Name
+  readonly schemaName: SchemaName
+  readonly [SequenceTypeId]: {
+    readonly kind: "sequence"
+    readonly name: Name
+    readonly schemaName: SchemaName
+  }
+  readonly qualifiedName: () => QualifiedName<Name, SchemaName>
+}
+
+export type AnyEnumDefinition = EnumDefinition<string, readonly [string, ...string[]], string | undefined>
+export type AnySequenceDefinition = SequenceDefinition<string, string | undefined>
+export type AnyDefinition = AnyEnumDefinition | AnySequenceDefinition
+
+export function enumType<
+  Name extends string,
+  const Values extends readonly [string, ...string[]]
+>(
+  name: Name,
+  values: Values
+): EnumDefinition<Name, Values, undefined>
+export function enumType<
+  Name extends string,
+  const Values extends readonly [string, ...string[]],
+  SchemaName extends string
+>(
+  name: Name,
+  values: Values,
+  schemaName: SchemaName
+): EnumDefinition<Name, Values, SchemaName>
+export function enumType(
+  name: string,
+  values: readonly [string, ...string[]],
+  schemaName?: string
+): EnumDefinition<string, readonly [string, ...string[]], string | undefined> {
+  const definition = Object.create(EnumProto)
+  definition.name = name
+  definition.values = values
+  definition.schemaName = schemaName
+  definition[EnumTypeId] = {
+    kind: "enum",
+    name,
+    values,
+    schemaName
+  }
+  return definition
+}
+
+export function sequence<Name extends string>(
+  name: Name
+): SequenceDefinition<Name, undefined>
+export function sequence<Name extends string, SchemaName extends string>(
+  name: Name,
+  schemaName: SchemaName
+): SequenceDefinition<Name, SchemaName>
+export function sequence(
+  name: string,
+  schemaName?: string
+): SequenceDefinition<string, string | undefined> {
+  const definition = Object.create(SequenceProto)
+  definition.name = name
+  definition.schemaName = schemaName
+  definition[SequenceTypeId] = {
+    kind: "sequence",
+    name,
+    schemaName
+  }
+  return definition
+}
+
+export const schema = <SchemaName extends string>(
+  schemaName: SchemaName
+) => ({
+  schemaName,
+  enumType: <
+    Name extends string,
+    const Values extends readonly [string, ...string[]]
+  >(
+    name: Name,
+    values: Values
+  ): EnumDefinition<Name, Values, SchemaName> =>
+    enumType(name, values, schemaName) as EnumDefinition<Name, Values, SchemaName>,
+  sequence: <
+    Name extends string
+  >(
+    name: Name
+  ): SequenceDefinition<Name, SchemaName> =>
+    sequence(name, schemaName) as SequenceDefinition<Name, SchemaName>
+})
+
+export const isEnumDefinition = (value: unknown): value is AnyEnumDefinition =>
+  typeof value === "object" && value !== null && EnumTypeId in value
+
+export const isSequenceDefinition = (value: unknown): value is AnySequenceDefinition =>
+  typeof value === "object" && value !== null && SequenceTypeId in value

package/src/postgres/schema.ts

@@ -0,0 +1,35 @@
+import { schema as makeTableSchemaNamespace, type TableSchemaNamespace } from "../internal/table.js"
+import { enumType, sequence, type EnumDefinition, type SequenceDefinition } from "./schema-management.js"
+
+export type SchemaNamespace<SchemaName extends string> = TableSchemaNamespace<SchemaName> & {
+  readonly enum: <
+    Name extends string,
+    const Values extends readonly [string, ...string[]]
+  >(
+    name: Name,
+    values: Values
+  ) => EnumDefinition<Name, Values, SchemaName>
+  readonly sequence: <
+    Name extends string
+  >(
+    name: Name
+  ) => SequenceDefinition<Name, SchemaName>
+}
+
+export const schema = <SchemaName extends string>(
+  schemaName: SchemaName
+): SchemaNamespace<SchemaName> => ({
+  ...makeTableSchemaNamespace(schemaName),
+  enum: <
+    Name extends string,
+    const Values extends readonly [string, ...string[]]
+  >(
+    name: Name,
+    values: Values
+  ) => enumType(name, values, schemaName) as EnumDefinition<Name, Values, SchemaName>,
+  sequence: <
+    Name extends string
+  >(
+    name: Name
+  ) => sequence(name, schemaName) as SequenceDefinition<Name, SchemaName>
+})