effect-qb 0.15.0 → 0.17.0

package/src/sqlite/json.ts

@@ -0,0 +1,2 @@
+/** SQLite JSON expression helpers. */
+export { json } from "./internal/dsl.js"

package/src/sqlite/query.ts

@@ -0,0 +1,196 @@
+import {
+  type AnyTableFunctionSource,
+  type AnyUnnestSource,
+  type AnyValuesSource,
+  type CapabilitiesOfPlan,
+  type CompletePlan,
+  type DialectCompatiblePlan,
+  type DerivedSourceRequiredError,
+  type CteSource,
+  type EffectiveNullability,
+  type ExpressionInput,
+  type ExpressionOutput,
+  type GroupByInput,
+  type MergeCapabilities,
+  type MergeCapabilityTuple,
+  type HavingPredicateInput,
+  type OrderDirection,
+  type OutputOfSelection,
+  type MutationTargetLike,
+  type NumericExpressionInput,
+  type PredicateInput,
+  type QueryCapability,
+  type QueryPlan,
+  type QueryRequirement,
+  type SetCompatiblePlan,
+  type SetCompatibleRightPlan,
+  type SetOperator,
+  type QueryStatement,
+  type ResultRow,
+  type ResultRows,
+  type RuntimeResultRow,
+  type RuntimeResultRows,
+  type SchemaTableLike,
+  type SourceCapabilitiesOf,
+  type SourceRequiredOf,
+  type SourceRequirementError,
+  type StatementOfPlan,
+  type StringExpressionInput
+} from "../internal/query.js"
+import {
+  type PublicNonStructuredFromApi,
+  type PublicStructuredFromConstraint,
+  type PublicStructuredFromResult,
+  type as sqliteType,
+  values,
+  unnest,
+  select,
+  insert,
+  from as dslFrom
+} from "./internal/dsl.js"
+
+export {
+  literal,
+  column,
+  cast,
+  eq,
+  neq,
+  lt,
+  lte,
+  gt,
+  gte,
+  isNull,
+  isNotNull,
+  like,
+  ilike,
+  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,
+  generateSeries,
+  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"
+import type * as Expression from "../internal/scalar.js"
+export { sqliteType as type }
+
+type SqliteMutationValueInput<Value> =
+  | Value
+  | Expression.Scalar<Value, Expression.DbType.Any, Expression.Nullability, "sqlite", Expression.ScalarKind, Expression.BindingId>
+
+export type MutationInputOf<Shape> = {
+  readonly [K in keyof Shape]: SqliteMutationValueInput<Shape[K]>
+}
+
+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, "sqlite">
+) => PublicStructuredFromResult<PlanValue, CurrentSource, "sqlite">
+
+export const from: StructuredFromApi & PublicNonStructuredFromApi = dslFrom as StructuredFromApi & PublicNonStructuredFromApi
+
+export type {
+  CapabilitiesOfPlan,
+  CompletePlan,
+  DialectCompatiblePlan,
+  DerivedSourceRequiredError,
+  CteSource,
+  EffectiveNullability,
+  ExpressionInput,
+  ExpressionOutput,
+  GroupByInput,
+  MergeCapabilities,
+  MergeCapabilityTuple,
+  HavingPredicateInput,
+  OrderDirection,
+  OutputOfSelection,
+  MutationTargetLike,
+  NumericExpressionInput,
+  PredicateInput,
+  QueryCapability,
+  QueryPlan,
+  QueryStatement,
+  QueryRequirement,
+  SetCompatiblePlan,
+  SetCompatibleRightPlan,
+  SetOperator,
+  ResultRow,
+  ResultRows,
+  RuntimeResultRow,
+  RuntimeResultRows,
+  SchemaTableLike,
+  SourceCapabilitiesOf,
+  SourceRequiredOf,
+  SourceRequirementError,
+  StatementOfPlan,
+  StringExpressionInput
+}
+
+export { union_query_capabilities } from "../internal/query.js"

package/src/sqlite/renderer.ts

@@ -0,0 +1,24 @@
+import * as CoreRenderer from "../internal/renderer.js"
+import type * as Expression from "../internal/scalar.js"
+import { renderSqlitePlan } from "./internal/renderer.js"
+
+/** SQLite-specialized rendered query shape. */
+export type RenderedQuery<Row> = CoreRenderer.RenderedQuery<Row, "sqlite">
+/** Extracts the row type carried by a SQLite rendered query. */
+export type RowOf<Value extends RenderedQuery<any>> = CoreRenderer.RowOf<Value>
+/** SQLite-specialized renderer contract. */
+export type Renderer = CoreRenderer.Renderer<"sqlite">
+
+export interface MakeOptions {
+  readonly valueMappings?: Expression.DriverValueMappings
+}
+
+export { TypeId } from "../internal/renderer.js"
+export type { Projection } from "../internal/renderer.js"
+
+/** Creates the built-in SQLite renderer. */
+export const make = (options: MakeOptions = {}): Renderer =>
+  CoreRenderer.make("sqlite", (plan) => renderSqlitePlan(plan, options))
+
+/** Shared built-in SQLite renderer instance. */
+export const sqlite = make()

package/src/sqlite/table.ts

@@ -0,0 +1,183 @@
+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 = "sqlite"
+
+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>

package/src/sqlite.ts

@@ -0,0 +1,22 @@
+/** SQLite-specialized column-definition DSL. */
+export * as Column from "./sqlite/column.js"
+/** SQLite datatype witnesses and coercion families. */
+export * as Datatypes from "./sqlite/datatypes/index.js"
+/** SQLite error catalog and error normalization helpers. */
+export * as Errors from "./sqlite/errors/index.js"
+/** Shared scalar SQL interfaces and DB-type descriptors. */
+export * as Scalar from "./internal/scalar.js"
+/** SQLite-specialized SQL function expressions. */
+export * as Function from "./sqlite/function/index.js"
+/** SQLite-specialized JSON expression helpers. */
+export * as Json from "./sqlite/json.js"
+/** SQLite-specialized typed query execution contracts. */
+export * as Executor from "./sqlite/executor.js"
+/** Shared logical row-set interfaces. */
+export * as RowSet from "./internal/row-set.js"
+/** SQLite-specialized query-construction DSL. */
+export * as Query from "./sqlite/query.js"
+/** SQLite-specialized table-definition DSL. */
+export * as Table from "./sqlite/table.js"
+/** SQLite-specialized built-in renderer entrypoint. */
+export * as Renderer from "./sqlite/renderer.js"