effect-qb 0.12.3 → 0.14.0

package/src/postgres/query.ts

@@ -1,5 +1,4 @@
-import * as Expression from "../internal/expression.js"
-import { postgresDatatypes } from "./datatypes/index.js"
+import { postgresQuery } from "./private/query.js"
 import {
   type CapabilitiesOfPlan,
   type CompletePlan,
@@ -37,22 +36,9 @@ import {
   type StatementOfPlan,
   type StringExpressionInput
 } from "../internal/query.js"
-import { makeDialectQuery } from "../internal/query-factory.js"
-
-const postgresQuery = makeDialectQuery({
-  dialect: "postgres",
-  textDb: { dialect: "postgres", kind: "text" } as Expression.DbType.PgText,
-  numericDb: { dialect: "postgres", kind: "float8" } as Expression.DbType.PgFloat8,
-  boolDb: { dialect: "postgres", kind: "bool" } as Expression.DbType.PgBool,
-  timestampDb: { dialect: "postgres", kind: "timestamp" } as Expression.DbType.PgTimestamp,
-  nullDb: { dialect: "postgres", kind: "null" } as Expression.DbType.Base<"postgres", "null">,
-  type: postgresDatatypes
-})
 
 export const literal = postgresQuery.literal
-export const cast = postgresQuery.cast
-export const type = postgresQuery.type
-export const json = postgresQuery.json
+export const column = postgresQuery.column
 export const eq = postgresQuery.eq
 export const neq = postgresQuery.neq
 export const lt = postgresQuery.lt
@@ -61,10 +47,12 @@ export const gt = postgresQuery.gt
 export const gte = postgresQuery.gte
 export const isNull = postgresQuery.isNull
 export const isNotNull = postgresQuery.isNotNull
-export const upper = postgresQuery.upper
-export const lower = postgresQuery.lower
 export const like = postgresQuery.like
 export const ilike = postgresQuery.ilike
+export const regexMatch = postgresQuery.regexMatch
+export const regexIMatch = postgresQuery.regexIMatch
+export const regexNotMatch = postgresQuery.regexNotMatch
+export const regexNotIMatch = postgresQuery.regexNotIMatch
 export const and = postgresQuery.and
 export const or = postgresQuery.or
 export const not = postgresQuery.not
@@ -72,22 +60,13 @@ export const all = postgresQuery.all
 export const any = postgresQuery.any
 const case_ = postgresQuery.case
 export const match = postgresQuery.match
-export const coalesce = postgresQuery.coalesce
 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 concat = postgresQuery.concat
 export const exists = postgresQuery.exists
-export const over = postgresQuery.over
-export const rowNumber = postgresQuery.rowNumber
-export const rank = postgresQuery.rank
-export const denseRank = postgresQuery.denseRank
-export const count = postgresQuery.count
-export const max = postgresQuery.max
-export const min = postgresQuery.min
 export const isDistinctFrom = postgresQuery.isDistinctFrom
 export const isNotDistinctFrom = postgresQuery.isNotDistinctFrom
 export const excluded = postgresQuery.excluded
@@ -103,7 +82,6 @@ export const values = postgresQuery.values
 export const unnest = postgresQuery.unnest
 export const generateSeries = postgresQuery.generateSeries
 export const returning = postgresQuery.returning
-export const defaultValues = postgresQuery.defaultValues
 export const onConflict = postgresQuery.onConflict
 export const insert = postgresQuery.insert
 export const update = postgresQuery.update

package/src/postgres/schema-expression.ts

@@ -0,0 +1,16 @@
+export {
+  TypeId,
+  fromAst,
+  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/expression.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>
+})