effect-qb 0.16.0 → 0.19.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-qb",
-  "version": "0.16.0",
+  "version": "0.19.0",
   "type": "module",
   "license": "MIT",
   "repository": {
@@ -21,6 +21,10 @@
     "README.md"
   ],
   "exports": {
+    ".": {
+      "types": "./src/index.ts",
+      "import": "./dist/index.js"
+    },
     "./postgres": {
       "types": "./src/postgres.ts",
       "import": "./dist/postgres.js"
@@ -33,11 +37,17 @@
       "types": "./src/mysql.ts",
       "import": "./dist/mysql.js"
     },
+    "./sqlite": {
+      "types": "./src/sqlite.ts",
+      "import": "./dist/sqlite.js"
+    },
     "./package.json": "./package.json"
   },
   "imports": {
+    "#standard": "./src/standard.ts",
     "#postgres": "./src/postgres.ts",
     "#mysql": "./src/mysql.ts",
+    "#sqlite": "./src/sqlite.ts",
     "#internal/*": "./src/internal/*"
   },
   "publishConfig": {
@@ -52,9 +62,11 @@
     "@typescript/native-preview": "beta"
   },
   "dependencies": {
+    "pgsql-ast-parser": "^12.0.2"
+  },
+  "peerDependencies": {
     "@effect/experimental": "^0.57.0",
     "@effect/sql": "^0.48.0",
-    "effect": "^3.19.3",
-    "pgsql-ast-parser": "^12.0.2"
+    "effect": "^3.19.3"
   }
 }

package/src/casing.ts

@@ -0,0 +1,71 @@
+import * as InternalCasing from "./internal/casing.js"
+import * as BaseTable from "./internal/table.js"
+import * as Table from "./standard/table.js"
+
+export type Style = InternalCasing.Style
+export type Options = InternalCasing.Options
+export type Input = Options | Style
+
+export interface TableFactory {
+  readonly table: typeof Table.make
+  readonly [InternalCasing.TypeId]: InternalCasing.State
+  readonly withCasing: (options: Input) => TableFactory
+}
+
+type CasingTarget =
+  | BaseTable.TableDefinition<any, any, any, any, any>
+  | {
+      readonly [InternalCasing.TypeId]: InternalCasing.State
+      readonly withCasing: (options: Options) => CasingTarget
+    }
+
+const isTable = (value: unknown): value is BaseTable.TableDefinition<any, any, any, any, any> =>
+  typeof value === "object" && value !== null && BaseTable.TypeId in value
+
+const allCategories = (style: Style): Options => ({
+  tables: style,
+  columns: style,
+  schemas: style,
+  indexes: style,
+  constraints: style,
+  types: style,
+  sequences: style
+})
+
+const normalize = (input: Input): Options =>
+  typeof input === "string" || typeof input === "function" ? allCategories(input) : input
+
+export function withCasing(options: Style): <Value extends CasingTarget>(value: Value) => Value
+export function withCasing(options: Options): <Value extends CasingTarget>(value: Value) => Value
+export function withCasing(options: Input) {
+  return <Value extends CasingTarget>(value: Value): Value => {
+    const normalized = normalize(options)
+    if (isTable(value)) {
+      return BaseTable.withCasing(value, normalized) as Value
+    }
+    return (value as Exclude<CasingTarget, BaseTable.TableDefinition<any, any, any, any, any>>).withCasing(normalized) as Value
+  }
+}
+
+export function make(options: Style): TableFactory
+export function make(options: Options): TableFactory
+export function make(options: Input): TableFactory {
+  const normalized = normalize(options)
+  const withFactoryCasing = withCasing(normalized)
+  const table = ((name: string, fields: any, schemaName?: string) =>
+    schemaName === undefined
+      ? Table.make(name, fields).pipe(withFactoryCasing)
+      : Table.make(name, fields, schemaName).pipe(withFactoryCasing)) as typeof Table.make
+  const factory = {
+    table,
+    [InternalCasing.TypeId]: {
+      casing: normalized
+    },
+    withCasing: (override: Input) => make(InternalCasing.merge(normalized, normalize(override)) ?? {})
+  }
+  return factory
+}
+
+export const apply = InternalCasing.apply
+export const applyCategory = InternalCasing.applyCategory
+export const merge = InternalCasing.merge

package/src/index.ts

@@ -0,0 +1,2 @@
+export * from "./standard.js"
+export * as Casing from "./casing.js"

package/src/internal/casing.ts

@@ -0,0 +1,89 @@
+export const TypeId: unique symbol = Symbol.for("effect-qb/Casing")
+
+export type Style =
+  | "preserve"
+  | "snake_case"
+  | "camelCase"
+  | "PascalCase"
+  | "kebab-case"
+  | "SCREAMING_SNAKE_CASE"
+  | ((name: string) => string)
+
+export interface Options {
+  readonly tables?: Style
+  readonly columns?: Style
+  readonly schemas?: Style
+  readonly indexes?: Style
+  readonly constraints?: Style
+  readonly types?: Style
+  readonly sequences?: Style
+}
+
+export type Category = keyof Options
+
+export interface State {
+  readonly casing?: Options
+}
+
+export const merge = (
+  base: Options | undefined,
+  override: Options | undefined
+): Options | undefined => {
+  if (base === undefined) {
+    return override
+  }
+  if (override === undefined) {
+    return base
+  }
+  return { ...base, ...override }
+}
+
+const words = (name: string): readonly string[] =>
+  name
+    .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+    .replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2")
+    .split(/[^A-Za-z0-9]+/)
+    .filter((part) => part.length > 0)
+
+const capitalize = (value: string): string =>
+  value.length === 0 ? value : `${value[0]!.toUpperCase()}${value.slice(1)}`
+
+const lowerWords = (name: string): readonly string[] =>
+  words(name).map((part) => part.toLowerCase())
+
+const applyNamedStyle = (style: Exclude<Style, (name: string) => string>, name: string): string => {
+  switch (style) {
+    case "preserve":
+      return name
+    case "snake_case":
+      return lowerWords(name).join("_")
+    case "camelCase": {
+      const parts = lowerWords(name)
+      const [head, ...tail] = parts
+      return head === undefined ? "" : `${head}${tail.map(capitalize).join("")}`
+    }
+    case "PascalCase":
+      return lowerWords(name).map(capitalize).join("")
+    case "kebab-case":
+      return lowerWords(name).join("-")
+    case "SCREAMING_SNAKE_CASE":
+      return lowerWords(name).join("_").toUpperCase()
+  }
+}
+
+export const apply = (
+  style: Style | undefined,
+  name: string
+): string => {
+  if (style === undefined) {
+    return name
+  }
+  return typeof style === "function" ? style(name) : applyNamedStyle(style, name)
+}
+
+export const applyCategory = (
+  options: Options | undefined,
+  category: Category,
+  name: string
+): string => apply(options?.[category], name)
+

package/src/internal/column-state.ts

@@ -4,6 +4,7 @@ import * as Schema from "effect/Schema"
 
 import * as Expression from "./scalar.js"
 import * as ExpressionAst from "./expression-ast.js"
+import type * as Casing from "./casing.js"
 import type * as SchemaExpression from "./schema-expression.js"
 
 /** Symbol used to attach column-definition metadata. */
@@ -183,6 +184,7 @@ export interface BoundColumn<
     readonly columnName: ColumnName
     readonly baseTableName: BaseTableName
     readonly schemaName?: string
+    readonly casing?: Casing.Options
   }
   readonly [Expression.TypeId]: Expression.State<
     Select,
@@ -227,7 +229,7 @@ export type AnyBoundColumn = BoundColumn<
 >
 
 const ColumnProto = {
-  pipe(this: unknown) {
+  pipe(this: Pipeable) {
     return pipeArguments(this, arguments)
   }
 }
@@ -236,7 +238,7 @@ const attachPipe = <Value extends object>(value: Value): Value => {
   Object.defineProperty(value, "pipe", {
     configurable: true,
     writable: true,
-    value: function(this: unknown) {
+    value: function(this: Value) {
       return pipeArguments(value, arguments)
     }
   })
@@ -407,17 +409,18 @@ export const remapColumnDefinition = <
     enum: metadata.enum
   }
   if (ExpressionAst.TypeId in column) {
-    next[ExpressionAst.TypeId] = (column as unknown as {
+    next[ExpressionAst.TypeId] = (column as {
       readonly [ExpressionAst.TypeId]: ExpressionAst.Any
     })[ExpressionAst.TypeId]
   }
   if (BoundColumnTypeId in column) {
-    next[BoundColumnTypeId] = (column as unknown as {
+    next[BoundColumnTypeId] = (column as {
       readonly [BoundColumnTypeId]: {
         readonly tableName: string
         readonly columnName: string
         readonly baseTableName: string
         readonly schemaName?: string
+        readonly casing?: Casing.Options
       }
     })[BoundColumnTypeId]
   }
@@ -436,7 +439,8 @@ export const bindColumn = <
   columnName: ColumnName,
   column: Column,
   baseTableName: BaseTableName,
-  schemaName?: SchemaName
+  schemaName?: SchemaName,
+  casing?: Casing.Options
 ): BoundColumnFrom<Column, TableName, ColumnName, BaseTableName> => {
   const brandName = `${tableName}.${columnName}`
   const schema = column.metadata.brand === true
@@ -467,7 +471,8 @@ export const bindColumn = <
     tableName,
     columnName,
     baseTableName,
-    schemaName
+    schemaName,
+    casing
   }
   return bound
 }

package/src/internal/column.ts

@@ -42,6 +42,7 @@ import {
   type SelectType,
   type UpdateType
 } from "./column-state.js"
+import type { NonEmptyStringInput } from "./table-options.js"
 
 type ReferentialAction = "noAction" | "restrict" | "cascade" | "setNull" | "setDefault"
 
@@ -223,6 +224,36 @@ type ForeignKeyOptions<Target extends AnyBoundColumn> = {
   readonly initiallyDeferred?: boolean
 }
 
+type NonEmptyOptionNameInput<Options> = Options extends { readonly name: infer Name extends string }
+  ? NonEmptyStringInput<Name> extends never ? never : unknown
+  : unknown
+
+type NonEmptyStringArrayInput<Values extends readonly string[]> =
+  [Extract<Values[number], "">] extends [never] ? unknown : never
+
+type NonEmptyIndexMethodInput<Options> = Options extends { readonly method: infer Method extends string }
+  ? NonEmptyStringInput<Method> extends never ? never : unknown
+  : unknown
+
+type NonEmptyIndexIncludeInput<Options> = Options extends { readonly include: infer Include extends readonly string[] }
+  ? NonEmptyStringArrayInput<Include>
+  : unknown
+
+type NonEmptyIndexOperatorClassInput<Options> = Options extends { readonly operatorClass: infer OperatorClass extends string }
+  ? NonEmptyStringInput<OperatorClass> extends never ? never : unknown
+  : unknown
+
+type NonEmptyIndexCollationInput<Options> = Options extends { readonly collation: infer Collation extends string }
+  ? NonEmptyStringInput<Collation> extends never ? never : unknown
+  : unknown
+
+type NonEmptyIndexMetadataInput<Options> =
+  & NonEmptyOptionNameInput<Options>
+  & NonEmptyIndexMethodInput<Options>
+  & NonEmptyIndexIncludeInput<Options>
+  & NonEmptyIndexOperatorClassInput<Options>
+  & NonEmptyIndexCollationInput<Options>
+
 type SchemaCompatibleColumn<
   Column extends AnyColumnDefinition,
   SchemaType extends Schema.Schema.Any
@@ -500,7 +531,7 @@ export const primaryKey = <Column extends AnyColumnDefinition>(
 type UniqueModifier = {
   <Column extends AnyColumnDefinition>(column: Column): UniqueColumn<Column>
   readonly options: <const Options extends ColumnUniqueOptions>(
-    options: Options
+    options: Options & NonEmptyOptionNameInput<Options>
   ) => <Column extends AnyColumnDefinition>(column: Column) => UniqueColumn<Column>
 }
 
@@ -550,11 +581,11 @@ export const generated = <Value extends DdlExpression>(value: Value) =>
     }) as GeneratedColumn<Column>
 
 /** Preserves the exact SQL type used for DDL rendering. */
-export const ddlType = <SqlType extends string>(sqlType: SqlType) =>
+export const ddlType = <SqlType extends string>(sqlType: NonEmptyStringInput<SqlType>) =>
   <Column extends AnyColumnDefinition>(column: Column): DdlTypedColumn<Column> =>
     mapColumn(column, {
       ...column.metadata,
-      ddlType: sqlType
+      ddlType: sqlType as SqlType
     }) as DdlTypedColumn<Column>
 
 /** Overrides how a column crosses the SQL driver boundary. */
@@ -590,13 +621,15 @@ export const array = <Options extends ArrayOptions | undefined = undefined>(
     }) as ArrayColumn<Column, Options>
 
 /** Marks a column as indexed. */
+type IndexPipe = <Column extends AnyColumnDefinition>(column: Column) => IndexedColumn<Column>
+
 export function index<Column extends AnyColumnDefinition>(
   column: Column
 ): IndexedColumn<Column>
 export function index<const Options extends ColumnIndexOptions>(
-  options: Options
+  options: Options & NonEmptyIndexMetadataInput<Options>
 ): <Column extends AnyColumnDefinition>(column: Column) => IndexedColumn<Column>
-export function index(arg: unknown): unknown {
+export function index(arg: AnyColumnDefinition | ColumnIndexOptions): IndexedColumn<AnyColumnDefinition> | IndexPipe {
   if (isColumnDefinitionValue(arg)) {
     return mapColumn(arg, {
       ...arg.metadata,
@@ -648,17 +681,21 @@ export const identityAlways = <Column extends AnyColumnDefinition>(
  *
  * The base, non-null select types must match.
  */
+type ForeignKeyPipe<Target extends AnyBoundColumn = AnyBoundColumn> = <Column extends AnyColumnDefinition>(
+  column: CompatibleReference<Column, Target>
+) => ReferencingColumn<Column, Target>
+
 export function foreignKey<Target extends AnyBoundColumn>(
   target: () => Target
 ): <Column extends AnyColumnDefinition>(
   column: CompatibleReference<Column, Target>
 ) => ReferencingColumn<Column, Target>
 export function foreignKey<const Options extends ForeignKeyOptions<AnyBoundColumn>>(
-  options: Options
+  options: Options & NonEmptyOptionNameInput<Options>
 ): <Column extends AnyColumnDefinition>(
   column: CompatibleReference<Column, ReturnType<Options["target"]>>
 ) => ReferencingColumn<Column, ReturnType<Options["target"]>>
-export function foreignKey(arg: unknown): unknown {
+export function foreignKey(arg: (() => AnyBoundColumn) | ForeignKeyOptions<AnyBoundColumn>): ForeignKeyPipe {
   if (typeof arg === "function") {
     const target = arg as () => AnyBoundColumn
     return <Column extends AnyColumnDefinition>(

package/src/internal/datatypes/define.ts

@@ -1,4 +1,5 @@
 import type * as Expression from "../scalar.js"
+import type { NonEmptyStringInput } from "../table-options.js"
 import type { DatatypeFamilySpec, DatatypeKindSpec } from "./shape.js"
 
 type DatatypeWitness<
@@ -20,7 +21,7 @@ export type DatatypeModule<
   Families extends Record<string, DatatypeFamilySpec>,
   Aliases extends Record<string, string> = Record<never, never>
 > = {
-  readonly custom: <Kind extends string>(kind: Kind) => Expression.DbType.Base<Dialect, Kind>
+  readonly custom: <Kind extends string>(kind: NonEmptyStringInput<Kind>) => Expression.DbType.Base<Dialect, Kind>
 } & {
   readonly [Kind in keyof Kinds]: () => DatatypeWitness<Dialect, Kinds, Families, Kind & string>
 } & {

package/src/internal/datatypes/enrich.ts

@@ -0,0 +1,23 @@
+import type * as Expression from "../scalar.js"
+
+type DatatypeLookup = Readonly<Record<string, (() => Expression.DbType.Any) | undefined>>
+
+export const enrichDbType = <
+  Module extends object,
+  Db extends Expression.DbType.Any
+>(
+  datatypes: Module,
+  dbType: Db
+): Db => {
+  if (dbType.kind === "custom") {
+    return dbType
+  }
+  const lookup = datatypes as DatatypeLookup
+  if (!(dbType.kind in lookup)) {
+    return dbType
+  }
+  const candidate = lookup[dbType.kind]
+  return typeof candidate === "function"
+    ? { ...candidate(), ...dbType } as Db
+    : dbType
+}

package/src/internal/datatypes/lookup.ts

@@ -31,6 +31,13 @@ type BaseCastTargetsOf<Db extends Expression.DbType.Base<any, any>> =
     ? Target
     : never
 
+type DbTypeCompatibleWithDialect<
+  Db extends Expression.DbType.Any,
+  Dialect extends string
+> = Dialect extends "standard"
+  ? Db extends { readonly dialect: string } ? true : false
+  : Db extends { readonly dialect: Dialect | "standard" } ? true : false
+
 type BaseHasTextualTrait<Db extends Expression.DbType.Base<any, any>> =
   Db extends { readonly traits?: infer Traits }
     ? Traits extends { readonly textual: true }
@@ -103,8 +110,8 @@ export type CanCompareDbTypes<
   Left extends Expression.DbType.Any,
   Right extends Expression.DbType.Any,
   Dialect extends string
-> = Left extends { readonly dialect: Dialect }
-  ? Right extends { readonly dialect: Dialect }
+> = DbTypeCompatibleWithDialect<Left, Dialect> extends true
+  ? DbTypeCompatibleWithDialect<Right, Dialect> extends true
     ? CompareGroupOfDbType<Left> extends never
       ? false
       : CompareGroupOfDbType<Right> extends never
@@ -125,8 +132,8 @@ export type CanContainDbTypes<
   Left extends Expression.DbType.Any,
   Right extends Expression.DbType.Any,
   Dialect extends string
-> = Left extends { readonly dialect: Dialect }
-  ? Right extends { readonly dialect: Dialect }
+> = DbTypeCompatibleWithDialect<Left, Dialect> extends true
+  ? DbTypeCompatibleWithDialect<Right, Dialect> extends true
     ? FamilyOfDbType<Left> extends "array" | "range" | "multirange"
       ? FamilyOfDbType<Right> extends "array" | "range" | "multirange"
         ? [CompareGroupOfDbType<Left>] extends [CompareGroupOfDbType<Right>]
@@ -142,7 +149,7 @@ export type CanContainDbTypes<
 export type CanTextuallyCoerceDbType<
   Db extends Expression.DbType.Any,
   Dialect extends string
-> = Db extends { readonly dialect: Dialect }
+> = DbTypeCompatibleWithDialect<Db, Dialect> extends true
   ? Db extends Expression.DbType.Domain<any, infer Base extends Expression.DbType.Any, any>
     ? CanTextuallyCoerceDbType<Base, Dialect>
     : Db extends Expression.DbType.Enum<any, any> | Expression.DbType.Set<any, any>
@@ -158,8 +165,8 @@ export type CanCastDbType<
   Source extends Expression.DbType.Any,
   Target extends Expression.DbType.Any,
   Dialect extends string
-> = Source extends { readonly dialect: Dialect }
-  ? Target extends { readonly dialect: Dialect }
+> = DbTypeCompatibleWithDialect<Source, Dialect> extends true
+  ? DbTypeCompatibleWithDialect<Target, Dialect> extends true
     ? Source extends Expression.DbType.Domain<any, infer Base extends Expression.DbType.Any, any>
       ? CanCastDbType<Base, Target, Dialect>
       : Target extends Expression.DbType.Domain<any, infer TargetBase extends Expression.DbType.Any, any>

package/src/internal/derived-table.ts

@@ -1,4 +1,4 @@
-import { pipeArguments } from "effect/Pipeable"
+import { pipeArguments, type Pipeable } from "effect/Pipeable"
 
 import * as Expression from "./scalar.js"
 import * as Plan from "./row-set.js"
@@ -11,13 +11,14 @@ import {
   type QueryPlan,
   getAst,
   makeExpression,
+  currentRequiredList,
   type SelectionOfPlan
 } from "./query.js"
 import * as ExpressionAst from "./expression-ast.js"
 import { flattenSelection } from "./projections.js"
 
 const DerivedProto = {
-  pipe(this: unknown) {
+  pipe(this: Pipeable) {
     return pipeArguments(this, arguments)
   }
 }
@@ -26,7 +27,7 @@ const attachPipe = <Value extends object>(value: Value): Value => {
   Object.defineProperty(value, "pipe", {
     configurable: true,
     writable: true,
-    value: function(this: unknown) {
+    value: function(this: Value) {
       return pipeArguments(value, arguments)
     }
   })
@@ -53,8 +54,6 @@ const setPath = (
   current[path[path.length - 1]!] = value
 }
 
-const pathAlias = (path: readonly string[]): string => path.join("__")
-
 const reboundedColumns = <
   PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>,
   Alias extends string
@@ -64,13 +63,8 @@ const reboundedColumns = <
 ): DerivedSelectionOf<SelectionOfPlan<PlanValue>, Alias> => {
   const ast = getAst(plan)
   const selection = {} as Record<string, unknown>
-  for (const projection of flattenSelection(ast.select as Record<string, unknown>)) {
-    const expectedAlias = pathAlias(projection.path)
-    if (projection.alias !== expectedAlias) {
-      throw new Error(
-        `Derived subqueries currently require path-based output aliases; expected '${expectedAlias}' for path '${projection.path.join(".")}'`
-      )
-    }
+  const projections = flattenSelection(ast.select as Record<string, unknown>)
+  for (const projection of projections) {
     const expression = projection.expression
     setPath(selection, projection.path, makeExpression({
       runtime: undefined as never,
@@ -148,7 +142,7 @@ export const makeLateralSource = <
   lateral.baseName = alias
   lateral.dialect = plan[Plan.TypeId].dialect
   lateral.plan = plan
-  lateral.required = undefined as never
+  lateral.required = currentRequiredList(plan[Plan.TypeId].required) as never
   lateral.columns = columns
   return lateral as unknown as LateralSource<PlanValue, Alias>
 }