effect-qb 0.17.0 → 0.19.0

package/src/standard/internal/renderer.ts

@@ -0,0 +1,45 @@
+import * as Query from "../../internal/query.js"
+import type * as Expression from "../../internal/scalar.js"
+import type * as Casing from "../../internal/casing.js"
+import { type RenderState } from "../../internal/dialect.js"
+import { type Projection } from "../../internal/projections.js"
+import { renderQueryAst } from "../../internal/sql-expression-renderer.js"
+import { standardDialect } from "../dialect.js"
+
+export interface StandardRenderResult {
+  readonly sql: string
+  readonly params: readonly unknown[]
+  readonly projections: readonly Projection[]
+  readonly valueMappings?: Expression.DriverValueMappings
+}
+
+export interface StandardRenderOptions {
+  readonly valueMappings?: Expression.DriverValueMappings
+  readonly casing?: Casing.Options
+}
+
+export const renderStandardPlan = <PlanValue extends Query.Plan.Any>(
+  plan: Query.DialectCompatiblePlan<PlanValue, "standard">,
+  options: StandardRenderOptions = {}
+): StandardRenderResult => {
+  const state: RenderState = {
+    params: [],
+    valueMappings: options.valueMappings,
+    casing: options.casing,
+    ctes: [],
+    cteNames: new Set<string>(),
+    cteSources: new Map<string, unknown>(),
+    sourceNames: new Map()
+  }
+  const rendered = renderQueryAst(
+    Query.getAst(plan as Query.Plan.Any) as any,
+    state,
+    standardDialect
+  )
+  return {
+    sql: rendered.sql,
+    params: state.params,
+    projections: rendered.projections,
+    valueMappings: state.valueMappings
+  }
+}

package/src/standard/query.ts

@@ -0,0 +1,152 @@
+import {
+  type as standardType
+} from "../internal/standard-dsl.js"
+import type * as Expression from "../internal/scalar.js"
+
+export {
+  literal,
+  column,
+  cast,
+  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,
+  from,
+  innerJoin,
+  leftJoin,
+  rightJoin,
+  fullJoin,
+  crossJoin,
+  distinct,
+  limit,
+  offset,
+  lock,
+  orderBy,
+  groupBy,
+  lower,
+  upper,
+  concat,
+  coalesce,
+  call,
+  count,
+  max,
+  min,
+  over,
+  rowNumber,
+  rank,
+  denseRank
+} from "../internal/standard-dsl.js"
+
+export { standardType as type }
+export { union_query_capabilities } from "../internal/query.js"
+
+export type MutationInputOf<Shape> = {
+  readonly [K in keyof Shape]:
+    | Shape[K]
+    | Expression.Scalar<Shape[K], Expression.DbType.Any, Expression.Nullability, "standard", Expression.ScalarKind, Expression.BindingId>
+}
+
+export type {
+  AnyTableFunctionSource,
+  AnyUnnestSource,
+  AnyValuesSource,
+  CapabilitiesOfPlan,
+  CompletePlan,
+  CteSource,
+  DialectCompatiblePlan,
+  DerivedSourceRequiredError,
+  EffectiveNullability,
+  ExpressionInput,
+  ExpressionOutput,
+  GroupByInput,
+  HavingPredicateInput,
+  MergeCapabilities,
+  MergeCapabilityTuple,
+  MutationTargetLike,
+  NumericExpressionInput,
+  OrderDirection,
+  OutputOfSelection,
+  PredicateInput,
+  QueryCapability,
+  QueryPlan,
+  QueryRequirement,
+  QueryStatement,
+  ResultRow,
+  ResultRows,
+  RuntimeResultRow,
+  RuntimeResultRows,
+  SchemaTableLike,
+  SetCompatiblePlan,
+  SetCompatibleRightPlan,
+  SetOperator,
+  SourceCapabilitiesOf,
+  SourceRequiredOf,
+  SourceRequirementError,
+  StatementOfPlan,
+  StringExpressionInput
+} from "../internal/query.js"

package/src/standard/renderer.ts

@@ -0,0 +1,21 @@
+import * as CoreRenderer from "../internal/renderer.js"
+import type * as Casing from "../internal/casing.js"
+import type * as Expression from "../internal/scalar.js"
+import type { StandardDatatypeFamily, StandardDatatypeKind } from "./datatypes/spec.js"
+import { renderStandardPlan } from "./internal/renderer.js"
+
+export type RenderedQuery<Row> = CoreRenderer.RenderedQuery<Row, "standard">
+
+export type RowOf<Value extends RenderedQuery<any>> = CoreRenderer.RowOf<Value>
+
+export type Renderer = CoreRenderer.Renderer<"standard">
+
+export type ValueMappings = Expression.DriverValueMappingsFor<StandardDatatypeKind | "uuid", StandardDatatypeFamily | "uuid">
+
+export interface MakeOptions {
+  readonly valueMappings?: ValueMappings
+  readonly casing?: Casing.Options
+}
+
+export const make = (options: MakeOptions = {}): Renderer =>
+  CoreRenderer.makeTrusted("standard", (plan) => renderStandardPlan(plan, options))

package/src/standard/table.ts

@@ -0,0 +1,147 @@
+import type { AnyColumnDefinition } from "../internal/column-state.js"
+import * as BaseTable from "../internal/table.js"
+
+type Dialect = string
+
+type DialectColumn = AnyColumnDefinition
+
+type DialectFieldMap = Record<string, DialectColumn>
+
+type InlinePrimaryKeyKeys<Fields extends DialectFieldMap> = Extract<{
+  [K in keyof Fields]: Fields[K]["metadata"]["primaryKey"] extends true ? K : never
+}[keyof Fields], string>
+
+export type TableDefinition<
+  Name extends string,
+  Fields extends DialectFieldMap,
+  PrimaryKeyColumns extends keyof Fields & string = InlinePrimaryKeyKeys<Fields>,
+  Kind extends "schema" | "alias" = "schema",
+  SchemaName extends string = "public"
+> = BaseTable.TableDefinition<Name, Fields, PrimaryKeyColumns, Kind, SchemaName>
+
+export type TableClassStatic<
+  Name extends string,
+  Fields extends DialectFieldMap,
+  PrimaryKeyColumns extends keyof Fields & string = InlinePrimaryKeyKeys<Fields>,
+  SchemaName extends string = "public"
+> = BaseTable.TableClassStatic<Name, Fields, PrimaryKeyColumns, SchemaName>
+
+export type AnyTable = BaseTable.AnyTable<Dialect>
+
+type FieldsOfTable<Table extends BaseTable.AnyTable> = Table[typeof BaseTable.TypeId]["fields"] extends infer Fields extends DialectFieldMap
+  ? Fields
+  : never
+
+type PrimaryKeyOfTable<Table extends BaseTable.AnyTable> = Table[typeof BaseTable.TypeId]["primaryKey"][number]
+
+type SchemaNameOfTable<Table extends BaseTable.AnyTable> =
+  Table[typeof BaseTable.TypeId]["schemaName"] extends infer SchemaName extends string ? SchemaName : "public"
+
+export type TableOption = BaseTable.TableOption
+
+export const TypeId = BaseTable.TypeId
+export const OptionsSymbol = BaseTable.OptionsSymbol
+export const options = BaseTable.options
+export const option = BaseTable.option
+
+export function make<
+  Name extends string,
+  Fields extends DialectFieldMap
+>(
+  name: BaseTable.NonEmptyStringInput<Name>,
+  fields: Fields & BaseTable.NonEmptyFieldMap<Fields>
+): TableDefinition<Name, Fields, InlinePrimaryKeyKeys<Fields>, "schema", "public">
+export function make<
+  Name extends string,
+  Fields extends DialectFieldMap,
+  const SchemaName extends string
+>(
+  name: BaseTable.NonEmptyStringInput<Name>,
+  fields: Fields & BaseTable.NonEmptyFieldMap<Fields>,
+  schemaName: BaseTable.NonEmptySchemaNameInput<SchemaName>
+): TableDefinition<Name, Fields, InlinePrimaryKeyKeys<Fields>, "schema", SchemaName>
+export function make(
+  name: string,
+  fields: DialectFieldMap,
+  schemaName?: string
+): TableDefinition<string, DialectFieldMap, string, "schema", string> {
+  return arguments.length >= 3
+    ? BaseTable.make(name, fields, schemaName as string) as TableDefinition<string, DialectFieldMap, string, "schema", string>
+    : BaseTable.make(name, fields) as TableDefinition<string, DialectFieldMap, string, "schema", string>
+}
+
+export const alias = <
+  Table extends AnyTable,
+  AliasName extends string
+>(
+  table: Table,
+  aliasName: BaseTable.LiteralStringInput<AliasName>
+): TableDefinition<
+  AliasName,
+  FieldsOfTable<Table>,
+  PrimaryKeyOfTable<Table>,
+  "alias",
+  SchemaNameOfTable<Table>
+> =>
+  BaseTable.alias(table as any, aliasName) as TableDefinition<
+    AliasName,
+    FieldsOfTable<Table>,
+    PrimaryKeyOfTable<Table>,
+    "alias",
+    SchemaNameOfTable<Table>
+  >
+
+type ClassApi = {
+  <Self = never>(
+    name: "",
+    schemaName?: string | undefined
+  ): never
+  <Self = never>(
+    name: string,
+    schemaName: ""
+  ): never
+  <Self = never, const SchemaName extends string = "public", const Name extends string = string>(
+    name: BaseTable.NonEmptyStringInput<Name>,
+    schemaName?: BaseTable.NonEmptySchemaNameInput<SchemaName>
+  ): <
+    Fields extends DialectFieldMap
+  >(fields: Fields & BaseTable.NonEmptyFieldMap<Fields>) => [Self] extends [never]
+    ? BaseTable.MissingSelfGeneric
+    : TableClassStatic<Name, Fields, InlinePrimaryKeyKeys<Fields>, SchemaName>
+}
+
+export const Class: ClassApi = ((
+  name: string,
+  schemaName: string | undefined = undefined
+) => {
+  const base = BaseTable.Class(name as never, schemaName)
+  return base
+}) as ClassApi
+
+export const primaryKey = BaseTable.primaryKey
+export const unique = BaseTable.unique
+export const index = BaseTable.index
+export const foreignKey = <
+  LocalColumns extends string | readonly string[],
+  TargetTable extends AnyTable,
+  TargetColumns extends string | readonly string[]
+>(
+  columns: LocalColumns & BaseTable.NonEmptyColumnInput<LocalColumns>,
+  target: () => TargetTable,
+  referencedColumns: TargetColumns & BaseTable.NonEmptyColumnInput<TargetColumns> & BaseTable.MatchingColumnArityInput<LocalColumns, TargetColumns>
+) =>
+  BaseTable.foreignKey<LocalColumns, TargetTable, TargetColumns>(
+    columns as LocalColumns & BaseTable.NonEmptyColumnInput<LocalColumns>,
+    target,
+    referencedColumns as TargetColumns & BaseTable.NonEmptyColumnInput<TargetColumns> & BaseTable.MatchingColumnArityInput<LocalColumns, TargetColumns>
+  )
+
+export const check = BaseTable.check
+
+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>

package/src/standard.ts

@@ -0,0 +1,18 @@
+/** Standard SQL column-definition DSL. */
+export * as Column from "./standard/column.js"
+/** Standard SQL datatype witnesses and coercion families. */
+export * as Datatypes from "./standard/datatypes/index.js"
+/** Shared scalar SQL interfaces and DB-type descriptors. */
+export * as Scalar from "./internal/scalar.js"
+/** Standard SQL function expressions. */
+export * as Function from "./standard/function/index.js"
+/** Standard SQL typed query execution contracts. */
+export * as Executor from "./internal/executor.js"
+/** Shared logical row-set interfaces. */
+export * as RowSet from "./internal/row-set.js"
+/** Standard SQL query-construction DSL. */
+export * as Query from "./standard/query.js"
+/** Standard SQL table-definition DSL. */
+export * as Table from "./standard/table.js"
+/** Standard SQL built-in renderer entrypoint. */
+export * as Renderer from "./standard/renderer.js"

package/src/internal/aggregation-validation.ts

@@ -1,57 +0,0 @@
-import * as Expression from "./scalar.js"
-import { groupingKeyOfExpression } from "./grouping-key.js"
-
-/** Recursive selection value accepted by aggregate-shape validation. */
-export type SelectionValue =
-  | Expression.Any
-  | {
-      readonly [key: string]: SelectionValue
-    }
-
-const isExpression = (value: unknown): value is Expression.Any =>
-  typeof value === "object" && value !== null && Expression.TypeId in value
-
-const selectionHasAggregate = (selection: SelectionValue): boolean => {
-  if (isExpression(selection)) {
-    return selection[Expression.TypeId].kind === "aggregate"
-  }
-  return Object.values(selection).some((value) => selectionHasAggregate(value))
-}
-
-const isGroupedSelectionValid = (
-  selection: SelectionValue,
-  groupedExpressions: ReadonlySet<string>
-): boolean => {
-  if (isExpression(selection)) {
-    const aggregation = selection[Expression.TypeId].kind
-    if (aggregation === "aggregate") {
-      return true
-    }
-    if (aggregation === "window") {
-      return false
-    }
-    if (Object.keys(selection[Expression.TypeId].dependencies).length === 0) {
-      return true
-    }
-    return groupedExpressions.has(groupingKeyOfExpression(selection))
-  }
-  return Object.values(selection).every((value) => isGroupedSelectionValid(value, groupedExpressions))
-}
-
-/**
- * Validates that grouped/scalar selection mixing is legal for the provided
- * `groupBy(...)` expressions.
- */
-export const validateAggregationSelection = (
-  selection: SelectionValue,
-  grouped: readonly Expression.Any[]
-): void => {
-  const groupedExpressions = new Set(grouped.map(groupingKeyOfExpression))
-  const hasAggregate = selectionHasAggregate(selection)
-  const isValid = hasAggregate || grouped.length > 0
-    ? isGroupedSelectionValid(selection, groupedExpressions)
-    : true
-  if (!isValid) {
-    throw new Error("Invalid grouped selection: scalar expressions must be covered by groupBy(...) when aggregates are present")
-  }
-}

package/src/mysql/table.ts

@@ -1,183 +0,0 @@
-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"
-
-type Dialect = "mysql"
-
-type DialectColumn = AnyColumnDefinition & {
-  readonly [ColumnTypeId]: {
-    readonly dbType: Expression.DbType.Any & { readonly dialect: Dialect }
-  }
-}
-
-type DialectFieldMap = Record<string, DialectColumn>
-
-type InlinePrimaryKeyKeys<Fields extends DialectFieldMap> = Extract<{
-  [K in keyof Fields]: Fields[K]["metadata"]["primaryKey"] extends true ? K : never
-}[keyof Fields], string>
-
-export type TableDefinition<
-  Name extends string,
-  Fields extends DialectFieldMap,
-  PrimaryKeyColumns extends keyof Fields & string = InlinePrimaryKeyKeys<Fields>,
-  Kind extends "schema" | "alias" = "schema",
-  SchemaName extends string | undefined = undefined
-> = BaseTable.TableDefinition<Name, Fields, PrimaryKeyColumns, Kind, SchemaName>
-
-export type TableClassStatic<
-  Name extends string,
-  Fields extends DialectFieldMap,
-  PrimaryKeyColumns extends keyof Fields & string = InlinePrimaryKeyKeys<Fields>,
-  SchemaName extends string | undefined = undefined
-> = BaseTable.TableClassStatic<Name, Fields, PrimaryKeyColumns, SchemaName>
-
-export type AnyTable = BaseTable.AnyTable
-
-type FieldsOfTable<Table> = Table extends BaseTable.TableDefinition<any, infer Fields extends DialectFieldMap, any, any, any>
-  ? 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
-
-type ApplySchemaTableOptions<
-  Name extends string,
-  Fields extends DialectFieldMap,
-  PrimaryKeyColumns extends keyof Fields & string,
-  SchemaName extends string,
-  Options extends BaseTable.DeclaredTableOptions
-> = BaseTable.ApplyDeclaredOptions<
-  BaseTable.TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", SchemaName>,
-  Options
-> extends BaseTable.TableDefinition<any, any, infer AppliedPrimaryKeyColumns extends keyof Fields & string, "schema", any>
-  ? TableDefinition<Name, Fields, AppliedPrimaryKeyColumns, "schema", SchemaName>
-  : TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", SchemaName>
-
-export type TableSchemaNamespace<SchemaName extends string> = {
-  readonly schemaName: SchemaName
-  readonly table: <
-    Name extends string,
-    Fields extends DialectFieldMap,
-    const Options extends BaseTable.DeclaredTableOptions,
-    PrimaryKeyColumns extends keyof Fields & string = InlinePrimaryKeyKeys<Fields>
-  >(
-    name: Name,
-    fields: Fields,
-    ...options: Options & BaseTable.ValidateDeclaredOptions<BaseTable.TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", SchemaName>, Options>
-  ) => ApplySchemaTableOptions<Name, Fields, PrimaryKeyColumns, SchemaName, Options>
-}
-
-export type TableOption = BaseTable.TableOption
-
-export const TypeId = BaseTable.TypeId
-export const OptionsSymbol = BaseTable.OptionsSymbol
-export const options = BaseTable.options
-
-export const make = <
-  Name extends string,
-  Fields extends DialectFieldMap,
-  SchemaName extends string | undefined = undefined
->(
-  name: Name,
-  fields: Fields,
-  schemaName: SchemaName = undefined as SchemaName
-): TableDefinition<Name, Fields> =>
-  BaseTable.make(name, fields, schemaName) as TableDefinition<Name, Fields>
-
-export const schema = <SchemaName extends string>(
-  schemaName: SchemaName
-): TableSchemaNamespace<SchemaName> => {
-  const table = <
-    Name extends string,
-    Fields extends DialectFieldMap,
-    const Options extends BaseTable.DeclaredTableOptions,
-    PrimaryKeyColumns extends keyof Fields & string = InlinePrimaryKeyKeys<Fields>
-  >(
-    name: Name,
-    fields: Fields,
-    ...declaredOptions: Options & BaseTable.ValidateDeclaredOptions<BaseTable.TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", SchemaName>, Options>
-  ) =>
-    (BaseTable.schema(schemaName).table as (
-      name: Name,
-      fields: Fields,
-      ...options: BaseTable.DeclaredTableOptions
-    ) => BaseTable.TableDefinition<any, any, any, "schema", any>)(
-      name,
-      fields,
-      ...declaredOptions
-    ) as ApplySchemaTableOptions<Name, Fields, PrimaryKeyColumns, SchemaName, Options>
-  return {
-    schemaName,
-    table
-  } as unknown as TableSchemaNamespace<SchemaName>
-}
-
-export const alias = <
-  Table extends AnyTable,
-  AliasName extends string
->(
-  table: Table,
-  aliasName: AliasName
-): TableDefinition<
-  AliasName,
-  FieldsOfTable<Table>,
-  PrimaryKeyOfTable<Table>,
-  "alias",
-  SchemaNameOfTable<Table>
-> =>
-  BaseTable.alias(table as any, aliasName) as TableDefinition<
-    AliasName,
-    FieldsOfTable<Table>,
-    PrimaryKeyOfTable<Table>,
-    "alias",
-    SchemaNameOfTable<Table>
-  >
-
-export const Class = <Self = never, SchemaName extends string | undefined = undefined>(
-  name: string,
-  schemaName: SchemaName = undefined as SchemaName
-) => {
-  const base = BaseTable.Class<Self, SchemaName>(name, schemaName)
-  return base as unknown as <
-    Fields extends DialectFieldMap
-  >(fields: Fields) => [Self] extends [never]
-    ? BaseTable.MissingSelfGeneric
-    : TableClassStatic<typeof name, Fields, InlinePrimaryKeyKeys<Fields>, SchemaName>
-}
-
-export const primaryKey = BaseTable.primaryKey
-export const unique = BaseTable.unique
-export const index = BaseTable.index
-export const foreignKey = <
-  LocalColumns extends string | readonly string[],
-  TargetTable extends AnyTable,
-  TargetColumns extends string | readonly string[]
->(
-  columns: LocalColumns & BaseTable.NonEmptyColumnInput<LocalColumns>,
-  target: () => TargetTable,
-  referencedColumns: TargetColumns & BaseTable.NonEmptyColumnInput<TargetColumns> & BaseTable.MatchingColumnArityInput<LocalColumns, TargetColumns>
-): BaseTable.TableOption =>
-  BaseTable.foreignKey<LocalColumns, BaseTable.AnyTable, TargetColumns>(
-    columns as LocalColumns & BaseTable.NonEmptyColumnInput<LocalColumns>,
-    target as () => BaseTable.AnyTable,
-    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>