effect-qb 0.16.0 → 0.19.0

package/src/standard/datatypes/spec.ts

@@ -0,0 +1,98 @@
+import type { DatatypeFamilySpec, DatatypeKindSpec } from "../../internal/datatypes/shape.js"
+
+export const standardDatatypeFamilies = {
+  text: {
+    compareGroup: "text",
+    castTargets: ["text", "numeric", "integer", "real", "boolean", "date", "time", "datetime", "json", "blob", "null"],
+    traits: {
+      textual: true,
+      ordered: true
+    }
+  },
+  numeric: {
+    compareGroup: "numeric",
+    castTargets: ["numeric", "integer", "real", "text", "boolean", "date", "time", "datetime"],
+    traits: {
+      ordered: true
+    }
+  },
+  integer: {
+    compareGroup: "numeric",
+    castTargets: ["integer", "numeric", "real", "text", "boolean", "date", "time", "datetime"],
+    traits: {
+      ordered: true
+    }
+  },
+  real: {
+    compareGroup: "numeric",
+    castTargets: ["real", "numeric", "integer", "text", "boolean"],
+    traits: {
+      ordered: true
+    }
+  },
+  boolean: {
+    compareGroup: "boolean",
+    castTargets: ["boolean", "integer", "numeric", "text"],
+    traits: {}
+  },
+  date: {
+    compareGroup: "date",
+    castTargets: ["date", "time", "datetime", "text", "numeric", "integer"],
+    traits: {
+      ordered: true
+    }
+  },
+  time: {
+    compareGroup: "time",
+    castTargets: ["time", "date", "datetime", "text", "numeric", "integer"],
+    traits: {
+      ordered: true
+    }
+  },
+  datetime: {
+    compareGroup: "datetime",
+    castTargets: ["datetime", "date", "time", "text", "numeric", "integer"],
+    traits: {
+      ordered: true
+    }
+  },
+  json: {
+    compareGroup: "json",
+    castTargets: ["json", "text"],
+    traits: {}
+  },
+  blob: {
+    compareGroup: "blob",
+    castTargets: ["blob", "text"],
+    traits: {}
+  },
+  null: {
+    compareGroup: "null",
+    castTargets: ["text", "numeric", "integer", "real", "boolean", "date", "time", "datetime", "json", "blob", "null"],
+    traits: {}
+  }
+} as const satisfies Record<string, DatatypeFamilySpec>
+
+export const standardDatatypeKinds = {
+  text: { family: "text", runtime: "string" },
+  varchar: { family: "text", runtime: "string" },
+  char: { family: "text", runtime: "string" },
+  clob: { family: "text", runtime: "string" },
+  int: { family: "integer", runtime: "number" },
+  integer: { family: "integer", runtime: "number" },
+  bigint: { family: "integer", runtime: "bigintString" },
+  numeric: { family: "numeric", runtime: "decimalString" },
+  decimal: { family: "numeric", runtime: "decimalString" },
+  real: { family: "real", runtime: "number" },
+  double: { family: "real", runtime: "number" },
+  boolean: { family: "boolean", runtime: "boolean" },
+  date: { family: "date", runtime: "localDate" },
+  time: { family: "time", runtime: "localTime" },
+  datetime: { family: "datetime", runtime: "localDateTime" },
+  timestamp: { family: "datetime", runtime: "localDateTime" },
+  json: { family: "json", runtime: "json" },
+  blob: { family: "blob", runtime: "bytes" }
+} as const satisfies Record<string, DatatypeKindSpec>
+
+export type StandardDatatypeFamily = keyof typeof standardDatatypeFamilies
+export type StandardDatatypeKind = keyof typeof standardDatatypeKinds

package/src/standard/dialect.ts

@@ -0,0 +1,40 @@
+import { quoteDoubleQuotedIdentifier, type RenderState, type RenderValueContext, type SqlDialect } from "../internal/dialect.js"
+import { renderExpression, renderQueryAst } from "../internal/dialect-renderers/postgres.js"
+import { toDriverValue } from "../internal/runtime/driver-value-mapping.js"
+
+const quoteIdentifier = quoteDoubleQuotedIdentifier
+
+const renderLiteral = (value: unknown, state: RenderState, context: RenderValueContext = {}): string => {
+  const driverValue = toDriverValue(value, {
+    dialect: "standard",
+    valueMappings: state.valueMappings,
+    ...context
+  })
+  if (driverValue === null) {
+    return "null"
+  }
+  if (typeof driverValue === "boolean") {
+    return driverValue ? "true" : "false"
+  }
+  state.params.push(driverValue)
+  return "?"
+}
+
+export const standardDialect: SqlDialect<"standard"> = {
+  name: "standard",
+  quoteIdentifier,
+  renderLiteral,
+  renderTableReference(tableName, baseTableName, schemaName) {
+    const renderedBase = schemaName && schemaName !== "public"
+      ? `${quoteIdentifier(schemaName)}.${quoteIdentifier(baseTableName)}`
+      : quoteIdentifier(baseTableName)
+    return tableName === baseTableName
+      ? renderedBase
+      : `${renderedBase} as ${quoteIdentifier(tableName)}`
+  },
+  renderConcat(values) {
+    return `(${values.join(" || ")})`
+  },
+  renderQueryAst,
+  renderExpression
+}

package/src/standard/function/aggregate.ts

@@ -0,0 +1,2 @@
+/** Standard aggregate functions. */
+export { count, max, min } from "../query.js"

package/src/standard/function/core.ts

@@ -0,0 +1,2 @@
+/** Standard scalar core functions. */
+export { coalesce, call } from "../query.js"

package/src/standard/function/index.ts

@@ -0,0 +1,18 @@
+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 * as temporal from "./temporal.js"
+
+export { coalesce, 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"
+export {
+  currentDate,
+  currentTime,
+  currentTimestamp,
+  localTime,
+  localTimestamp,
+  now
+} from "./temporal.js"

package/src/standard/function/string.ts

@@ -0,0 +1,2 @@
+/** Standard string functions. */
+export { lower, upper, concat } from "../query.js"

package/src/standard/function/temporal.ts

@@ -0,0 +1,78 @@
+import type * as Schema from "effect/Schema"
+
+import type * as Expression from "../../internal/scalar.js"
+import type * as ExpressionAst from "../../internal/expression-ast.js"
+import { makeExpression } from "../../internal/query.js"
+import {
+  InstantStringSchema,
+  LocalDateStringSchema,
+  LocalDateTimeStringSchema,
+  LocalTimeStringSchema,
+  type InstantString,
+  type LocalDateString,
+  type LocalDateTimeString,
+  type LocalTimeString
+} from "../../internal/runtime/value.js"
+import { standardDatatypes } from "../datatypes/index.js"
+
+type TemporalExpression<
+  Runtime,
+  Db extends Expression.DbType.Any,
+  Name extends string
+> = Expression.Scalar<
+  Runtime,
+  Db,
+  "never",
+  "standard",
+  "scalar",
+  never
+> & {
+  readonly [ExpressionAst.TypeId]: ExpressionAst.FunctionCallNode<Name, readonly []>
+}
+
+const makeTemporal = <
+  Runtime,
+  Db extends Expression.DbType.Any,
+  Name extends string
+>(
+  name: Name,
+  dbType: Db,
+  runtimeSchema: Schema.Schema<Runtime, any, any>
+): TemporalExpression<Runtime, Db, Name> =>
+  makeExpression({
+    runtime: undefined as unknown as Runtime,
+    dbType,
+    runtimeSchema,
+    nullability: "never",
+    dialect: "standard",
+    kind: "scalar",
+    dependencies: {}
+  }, {
+    kind: "function",
+    name,
+    args: []
+  }) as TemporalExpression<Runtime, Db, Name>
+
+/** Standard current instant. */
+export const now = (): TemporalExpression<InstantString, ReturnType<typeof standardDatatypes.timestamp>, "now"> =>
+  makeTemporal("now", standardDatatypes.timestamp(), InstantStringSchema)
+
+/** Standard current date. */
+export const currentDate = (): TemporalExpression<LocalDateString, ReturnType<typeof standardDatatypes.date>, "current_date"> =>
+  makeTemporal("current_date", standardDatatypes.date(), LocalDateStringSchema)
+
+/** Standard current time. */
+export const currentTime = (): TemporalExpression<LocalTimeString, ReturnType<typeof standardDatatypes.time>, "current_time"> =>
+  makeTemporal("current_time", standardDatatypes.time(), LocalTimeStringSchema)
+
+/** Standard current timestamp. */
+export const currentTimestamp = (): TemporalExpression<LocalDateTimeString, ReturnType<typeof standardDatatypes.timestamp>, "current_timestamp"> =>
+  makeTemporal("current_timestamp", standardDatatypes.timestamp(), LocalDateTimeStringSchema)
+
+/** Standard local time. */
+export const localTime = (): TemporalExpression<LocalTimeString, ReturnType<typeof standardDatatypes.time>, "localtime"> =>
+  makeTemporal("localtime", standardDatatypes.time(), LocalTimeStringSchema)
+
+/** Standard local timestamp. */
+export const localTimestamp = (): TemporalExpression<LocalDateTimeString, ReturnType<typeof standardDatatypes.timestamp>, "localtimestamp"> =>
+  makeTemporal("localtimestamp", standardDatatypes.timestamp(), LocalDateTimeStringSchema)

package/src/standard/function/window.ts

@@ -0,0 +1,2 @@
+/** Standard window functions. */
+export { over, rowNumber, rank, denseRank } from "../query.js"

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"