effect-qb 0.12.3 → 0.14.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-qb",
-  "version": "0.12.3",
+  "version": "0.14.0",
   "type": "module",
   "files": [
     "dist",
@@ -12,31 +12,36 @@
       "types": "./src/postgres.ts",
       "import": "./dist/postgres.js"
     },
+    "./postgres/metadata": {
+      "types": "./src/postgres/metadata.ts",
+      "import": "./dist/postgres/metadata.js"
+    },
     "./mysql": {
       "types": "./src/mysql.ts",
       "import": "./dist/mysql.js"
     },
     "./package.json": "./package.json"
   },
+  "imports": {
+    "#postgres": "./src/postgres.ts",
+    "#mysql": "./src/mysql.ts",
+    "#internal/*": "./src/internal/*"
+  },
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
-    "build": "bun scripts/build-package.ts",
-    "test": "bun test",
-    "test:types": "bunx tsgo -p tsconfig.type-tests.json",
-    "test:integration": "bun scripts/test-integration.ts",
+    "build": "bun scripts/build.ts",
     "prepack": "bun run build"
   },
   "devDependencies": {
-    "@effect/sql-mysql2": "0.48.0",
-    "@effect/sql-pg": "0.48.0",
     "@types/bun": "latest",
     "@typescript/native-preview": "latest"
   },
   "dependencies": {
     "@effect/experimental": "^0.57.0",
     "@effect/sql": "^0.48.0",
-    "effect": "^3.19.3"
+    "effect": "^3.19.3",
+    "pgsql-ast-parser": "^12.0.2"
   }
 }

package/src/internal/column-state.ts

@@ -1,8 +1,10 @@
+import type * as Brand from "effect/Brand"
 import { pipeArguments, type Pipeable } from "effect/Pipeable"
 import * as Schema from "effect/Schema"
 
 import * as Expression from "./expression.js"
 import * as ExpressionAst from "./expression-ast.js"
+import type * as SchemaExpression from "./schema-expression.js"
 
 /** Symbol used to attach column-definition metadata. */
 export const ColumnTypeId: unique symbol = Symbol.for("effect-qb/Column")
@@ -12,9 +14,34 @@ export const BoundColumnTypeId: unique symbol = Symbol.for("effect-qb/BoundColum
 export type ColumnTypeId = typeof ColumnTypeId
 export type BoundColumnTypeId = typeof BoundColumnTypeId
 
+export type DdlExpression = Expression.Any | SchemaExpression.Any
+
 /** Lazy reference to another bound column. */
 export interface ColumnReference<Target = unknown> {
   readonly target: () => Target
+  readonly name?: string
+  readonly onUpdate?: "noAction" | "restrict" | "cascade" | "setNull" | "setDefault"
+  readonly onDelete?: "noAction" | "restrict" | "cascade" | "setNull" | "setDefault"
+  readonly deferrable?: boolean
+  readonly initiallyDeferred?: boolean
+}
+
+/** Inline single-column index metadata. */
+export interface ColumnIndexOptions {
+  readonly name?: string
+  readonly method?: string
+  readonly include?: readonly string[]
+  readonly predicate?: DdlExpression
+  readonly order?: "asc" | "desc"
+  readonly nulls?: "first" | "last"
+}
+
+/** Inline single-column unique-constraint metadata. */
+export interface ColumnUniqueOptions {
+  readonly name?: string
+  readonly nullsNotDistinct?: boolean
+  readonly deferrable?: boolean
+  readonly initiallyDeferred?: boolean
 }
 
 /** Complete static state tracked for a column definition. */
@@ -42,6 +69,20 @@ export interface ColumnState<
   readonly primaryKey: PrimaryKey
   readonly unique: Unique
   readonly references: Ref
+  readonly brand?: true
+  readonly index?: ColumnIndexOptions
+  readonly uniqueConstraint?: ColumnUniqueOptions
+  readonly defaultValue?: DdlExpression
+  readonly generatedValue?: DdlExpression
+  readonly ddlType?: string
+  readonly identity?: {
+    readonly generation: "always" | "byDefault"
+  }
+  readonly enum?: {
+    readonly name: string
+    readonly schemaName?: string
+    readonly values: readonly [string, ...string[]]
+  }
   readonly source: Source
   readonly dependencies: Dependencies
 }
@@ -93,6 +134,20 @@ export interface ColumnDefinition<
     readonly primaryKey: PrimaryKey
     readonly unique: Unique
     readonly references: Ref
+    readonly brand?: true
+    readonly index?: ColumnIndexOptions
+    readonly uniqueConstraint?: ColumnUniqueOptions
+    readonly defaultValue?: DdlExpression
+    readonly generatedValue?: DdlExpression
+    readonly ddlType?: string
+    readonly identity?: {
+      readonly generation: "always" | "byDefault"
+    }
+    readonly enum?: {
+      readonly name: string
+      readonly schemaName?: string
+      readonly values: readonly [string, ...string[]]
+    }
   }
 }
 
@@ -249,6 +304,11 @@ export const makeColumnDefinition = <
     primaryKey: metadata.primaryKey,
     unique: metadata.unique,
     references: metadata.references,
+    defaultValue: metadata.defaultValue,
+    generatedValue: metadata.generatedValue,
+    ddlType: metadata.ddlType,
+    identity: metadata.identity,
+    enum: metadata.enum,
     source: undefined as Source,
     dependencies: {} as Dependencies
   }
@@ -338,7 +398,12 @@ export const remapColumnDefinition = <
     generated: metadata.generated,
     primaryKey: metadata.primaryKey,
     unique: metadata.unique,
-    references: metadata.references
+    references: metadata.references,
+    defaultValue: metadata.defaultValue,
+    generatedValue: metadata.generatedValue,
+    ddlType: metadata.ddlType,
+    identity: metadata.identity,
+    enum: metadata.enum
   }
   if (ExpressionAst.TypeId in column) {
     next[ExpressionAst.TypeId] = (column as unknown as {
@@ -372,13 +437,17 @@ export const bindColumn = <
   baseTableName: BaseTableName,
   schemaName?: SchemaName
 ): BoundColumnFrom<Column, TableName, ColumnName, BaseTableName> => {
+  const brandName = `${tableName}.${columnName}`
+  const schema = column.metadata.brand === true
+    ? Schema.brand(brandName)(column.schema)
+    : column.schema
   const bound = Object.create(ColumnProto)
-  bound.schema = column.schema
+  bound.schema = schema
   bound.metadata = column.metadata
   bound[Expression.TypeId] = {
     runtime: undefined as SelectType<Column>,
     dbType: column.metadata.dbType,
-    runtimeSchema: column.schema,
+    runtimeSchema: schema,
     nullability: (column.metadata.nullable ? "maybe" : "never") as IsNullable<Column> extends true ? "maybe" : "never",
     dialect: column.metadata.dbType.dialect,
     aggregation: "scalar",
@@ -430,6 +499,13 @@ export type ReferencesOf<Column extends AnyColumnDefinition> = ColumnStateOf<Col
 /** Extracts the non-null select type of a column. */
 export type BaseSelectType<Column extends AnyColumnDefinition> = NonNullable<SelectType<Column>>
 
+type BrandedValue<
+  Value,
+  BrandName extends string
+> = [Extract<Value, null | undefined>] extends [never]
+  ? Value & Brand.Brand<BrandName>
+  : Exclude<Value, null | undefined> & Brand.Brand<BrandName> | Extract<Value, null | undefined>
+
 /** Rebinds a generic column definition to a specific table and key. */
 export type BoundColumnFrom<
   Column extends AnyColumnDefinition,
@@ -437,9 +513,15 @@ export type BoundColumnFrom<
   ColumnName extends string,
   BaseTableName extends string = TableName
 > = BoundColumn<
-  SelectType<Column>,
-  InsertType<Column>,
-  UpdateType<Column>,
+  Column["metadata"]["brand"] extends true
+    ? BrandedValue<SelectType<Column>, `${TableName}.${ColumnName}`>
+    : SelectType<Column>,
+  Column["metadata"]["brand"] extends true
+    ? BrandedValue<InsertType<Column>, `${TableName}.${ColumnName}`>
+    : InsertType<Column>,
+  Column["metadata"]["brand"] extends true
+    ? BrandedValue<UpdateType<Column>, `${TableName}.${ColumnName}`>
+    : UpdateType<Column>,
   ColumnStateOf<Column>["dbType"],
   IsNullable<Column>,
   HasDefault<Column>,