@remix-run/data-table 0.1.0 → 0.2.0

package/README.md

@@ -5,19 +5,20 @@ Typed relational query toolkit for JavaScript runtimes.
 ## Features
 
 - **One API Across Databases**: Same query and relation APIs across PostgreSQL, MySQL, and SQLite adapters
-- **Two Complementary Query Styles**: Use the chainable query builder for advanced queries or high-level database helpers for common CRUD
+- **One Query API**: Build reusable `Query` objects with `query(table)` and execute them with `db.exec(...)`, or use `db.query(table)` as shorthand
 - **Type-Safe Reads**: Typed `select`, relation loading, and predicate keys
-- **Validated Writes and Filters**: Values are parsed with your `remix/data-schema` definitions
+- **Optional Runtime Validation**: Add `validate(context)` at the table level for create/update validation and coercion
 - **Relation-First Queries**: `hasMany`, `hasOne`, `belongsTo`, `hasManyThrough`, and nested eager loading
 - **Safe Scoped Writes**: `update`/`delete` with `orderBy`/`limit` run safely in a transaction
+- **First-Class Migrations**: Up/down migrations with schema builders, runner controls, and dry-run planning
 - **Raw SQL Escape Hatch**: Execute SQL directly with `db.exec(sql\`...\`)`
 
 `data-table` gives you two complementary APIs:
 
-- [**Query Builder**](#query-builder) for expressive joins, aggregates, eager loading, and scoped writes
+- [**Query Objects**](#query-objects) for expressive joins, aggregates, eager loading, and scoped writes
 - [**CRUD Helpers**](#crud-helpers) for common create/read/update/delete flows (`find`, `create`, `update`, `delete`)
 
-Both APIs are type-safe and validate values using your [remix/data-schema](https://github.com/remix-run/remix/tree/main/packages/data-schema) definitions.
+Both APIs are type-safe. Runtime validation is opt-in with table-level `validate(context)`.
 
 ## Installation
 
@@ -36,28 +37,27 @@ Define tables once, then create a database with an adapter.
 
 ```ts
 import { Pool } from 'pg'
-import * as s from 'remix/data-schema'
-import { createDatabase, createTable, hasMany } from 'remix/data-table'
+import { column as c, createDatabase, hasMany, query, table } from 'remix/data-table'
 import { createPostgresDatabaseAdapter } from 'remix/data-table-postgres'
 
-let users = createTable({
+let users = table({
   name: 'users',
   columns: {
-    id: s.string(),
-    email: s.string(),
-    role: s.enum_(['customer', 'admin']),
-    created_at: s.number(),
+    id: c.uuid(),
+    email: c.varchar(255),
+    role: c.enum(['customer', 'admin']),
+    created_at: c.integer(),
   },
 })
 
-let orders = createTable({
+let orders = table({
   name: 'orders',
   columns: {
-    id: s.string(),
-    user_id: s.string(),
-    status: s.enum_(['pending', 'processing', 'shipped', 'delivered']),
-    total: s.number(),
-    created_at: s.number(),
+    id: c.uuid(),
+    user_id: c.uuid(),
+    status: c.enum(['pending', 'processing', 'shipped', 'delivered']),
+    total: c.decimal(10, 2),
+    created_at: c.integer(),
   },
 })
 
@@ -67,15 +67,18 @@ let pool = new Pool({ connectionString: process.env.DATABASE_URL })
 let db = createDatabase(createPostgresDatabaseAdapter(pool))
 ```
 
-## Query Builder
+## Query Objects
 
-Use `db.query(table)` when you need joins, custom shape selection, eager loading, or aggregate logic.
+Use `query(table)` when you want to build a standalone reusable query object. Execute it later with `db.exec(query)`. Use `db.query(table)` when you want the same chainable `Query` already bound to a database instance.
+
+### Standalone Query Builder
+
+`query(table)` is the primary query-builder API. It gives you an unbound `Query` value that can be composed, stored, reused, and executed against any compatible database instance.
 
 ```ts
-import { eq, ilike } from 'remix/data-table'
+import { eq, ilike, query } from 'remix/data-table'
 
-let recentPendingOrders = await db
-  .query(orders)
+let pendingOrdersForExampleUsers = query(orders)
   .join(users, eq(orders.user_id, users.id))
   .where({ status: 'pending' })
   .where(ilike(users.email, '%@example.com'))
@@ -87,32 +90,51 @@ let recentPendingOrders = await db
   })
   .orderBy(orders.created_at, 'desc')
   .limit(20)
-  .all()
+
+let recentPendingOrders = await db.exec(pendingOrdersForExampleUsers)
 ```
 
-Load relations with relation-scoped filtering and ordering:
+Unbound queries stay lazy until you pass them to `db.exec(...)`:
 
 ```ts
-let customers = await db
-  .query(users)
+let shippedCustomerQuery = query(users)
   .where({ role: 'customer' })
   .with({
     recentOrders: userOrders.where({ status: 'shipped' }).orderBy('created_at', 'desc').limit(3),
   })
-  .all()
+
+let customers = await db.exec(shippedCustomerQuery)
 
 // customers[0].recentOrders is fully typed
 ```
 
-Run scoped writes safely with the same chainable API:
+The same standalone query builder also handles terminal read and write operations:
+
+```ts
+let nextPendingOrder = await db.exec(
+  query(orders).where({ status: 'pending' }).orderBy('created_at', 'asc').first(),
+)
+
+await db.exec(
+  query(orders)
+    .where({ status: 'pending' })
+    .orderBy('created_at', 'asc')
+    .limit(100)
+    .update({ status: 'processing' }),
+)
+```
+
+### Bound Query Shorthand
+
+If you already have a `db` instance in hand and do not need a standalone query value, `db.query(table)` returns the same query builder already bound to that database:
 
 ```ts
-await db
+let recentPendingOrders = await db
   .query(orders)
   .where({ status: 'pending' })
-  .orderBy('created_at', 'asc')
-  .limit(100)
-  .update({ status: 'processing' })
+  .orderBy('created_at', 'desc')
+  .limit(20)
+  .all()
 ```
 
 ## CRUD Helpers
@@ -225,38 +247,80 @@ Return behavior:
 - `updateMany`/`deleteMany` -> `WriteResult`
 - `delete` -> `boolean`
 
-### Data Validation
-
-For write operations, data validation happens before SQL is executed so invalid data does not get written to the database.
+### Validation and Lifecycle
 
-`data-table` treats each column schema as both:
+Validation is optional and table-scoped. Define `validate(context)` to validate/coerce write
+payloads, and add lifecycle callbacks when you need custom read/write/delete behavior.
 
-- a runtime validator (is this input valid?)
-- a parser (what normalized value should be written?)
+```ts
+import { column as c, fail, table } from 'remix/data-table'
 
-If you're familiar with Zod, this is the same idea: schema-first validation where values are checked and parsed before use. In `data-table`, that parsing runs automatically on writes (`create`, `createMany`, `update`, `upsert`) so only schema-valid values are sent to the database. Invalid values and unknown columns fail fast before a write is attempted.
+let payments = table({
+  name: 'payments',
+  columns: {
+    id: c.uuid(),
+    amount: c.decimal(10, 2),
+  },
+  beforeWrite({ value }) {
+    return {
+      value: {
+        ...value,
+        amount: typeof value.amount === 'string' ? value.amount.trim() : value.amount,
+      },
+    }
+  },
+  validate({ operation, value }) {
+    if (operation === 'create' && typeof value.amount === 'string') {
+      let amount = Number(value.amount)
 
-Tables are also [Standard Schema](https://standardschema.dev/)-compatible, so you can run the same validation explicitly with `remix/data-schema` before writing:
+      if (!Number.isFinite(amount)) {
+        return fail('Expected a numeric amount', ['amount'])
+      }
 
-```ts
-import { parseSafe } from 'remix/data-schema'
+      return { value: { ...value, amount } }
+    }
 
-let result = parseSafe(users, {
-  id: 'u_004',
-  email: 'new@example.com',
-  role: 'customer',
+    return { value }
+  },
+  beforeDelete({ where }) {
+    if (where.length === 0) {
+      return fail('Refusing unscoped delete')
+    }
+  },
+  afterRead({ value }) {
+    if (!('amount' in value)) {
+      return { value }
+    }
+
+    return {
+      value: {
+        ...value,
+        // Example read-time shaping
+        amount:
+          typeof value.amount === 'number' ? Math.round(value.amount * 100) / 100 : value.amount,
+      },
+    }
+  },
 })
-
-if (!result.success) {
-  // Handle validation issues
-}
 ```
 
-Validation semantics match `create()`/`update()` input behavior:
+Use `fail(...)` in hooks when you want to return issues without manually building `{ issues: [...] }`.
+
+Validation and lifecycle semantics:
 
-- Partial objects are allowed
-- Unknown columns fail validation
-- Provided column values are parsed through each column schema
+- Write order is `beforeWrite -> validate -> timestamp/default touch -> execute -> afterWrite`
+- `validate` runs for writes (`create`, `createMany`, `insert`, `insertMany`, `update`, `updateMany`, `upsert`)
+- Hook context includes `{ operation: 'create' | 'update', tableName, value }`
+- Write payloads are partial objects
+- Unknown columns fail validation before and after hook processing
+- `beforeDelete` can veto deletes by returning `{ issues }`
+- `afterDelete` runs after successful deletes with `affectedRows`
+- `afterRead` runs for each loaded row (root rows, eager-loaded relation rows, and write-returning rows)
+- `afterRead` receives the current read shape, which may be partial/projection rows; guard field access accordingly
+- Predicate values (`where`, `having`, join predicates) are not runtime-validated
+- Lifecycle callbacks are synchronous; returning a Promise throws a validation error
+- Callback validation errors include `metadata.source` (`beforeWrite`, `validate`, `beforeDelete`, `afterRead`, etc.) for easier debugging
+- Callbacks do not introduce implicit transactions (use `db.transaction(...)` when you need rollback guarantees)
 
 ## Transactions
 
@@ -278,6 +342,175 @@ await db.transaction(async (tx) => {
 })
 ```
 
+## Migrations
+
+`data-table` includes a first-class migration system under `remix/data-table/migrations`.
+Migrations are adapter-driven: adapters execute SQL for their dialect/runtime, and SQL compilation
+is handled by adapter-owned compilers (with optional shared pure helpers from `data-table`).
+For adapter authors (including third-party adapters), shared SQL helper utilities are available at
+`remix/data-table/sql-helpers`.
+
+### Example Setup
+
+```txt
+app/
+  db/
+    migrations/
+      20260228090000_create_users.ts
+      20260301113000_add_user_status.ts
+    migrate.ts
+```
+
+- Keep migration files in one directory (for example `app/db/migrations`).
+- Name each file as `YYYYMMDDHHmmss_name.ts` (or `.js`, `.mjs`, `.cjs`, `.cts`).
+- Each file must `default` export `createMigration(...)`; `id` and `name` are inferred from filename.
+
+### Migration File Example
+
+```ts
+import { column as c, table } from 'remix/data-table'
+import { createMigration } from 'remix/data-table/migrations'
+
+let users = table({
+  name: 'users',
+  columns: {
+    id: c.integer().primaryKey(),
+    email: c.varchar(255).notNull().unique(),
+    created_at: c.timestamp({ withTimezone: true }).defaultNow(),
+  },
+})
+
+export default createMigration({
+  async up({ db, schema }) {
+    await schema.createTable(users)
+    await schema.createIndex(users, 'email', { unique: true })
+
+    if (db.adapter.dialect === 'sqlite') {
+      await db.exec('pragma foreign_keys = on')
+    }
+  },
+  async down({ schema }) {
+    await schema.dropTable(users, { ifExists: true })
+  },
+})
+```
+
+### Runner Script Example
+
+In `app/db/migrate.ts`:
+
+```ts
+import path from 'node:path'
+import { Pool } from 'pg'
+import { createPostgresDatabaseAdapter } from 'remix/data-table-postgres'
+import { createMigrationRunner } from 'remix/data-table/migrations'
+import { loadMigrations } from 'remix/data-table/migrations/node'
+
+let directionArg = process.argv[2] ?? 'up'
+let direction = directionArg === 'down' ? 'down' : 'up'
+let to = process.argv[3]
+
+let pool = new Pool({ connectionString: process.env.DATABASE_URL })
+let adapter = createPostgresDatabaseAdapter(pool)
+let migrations = await loadMigrations(path.resolve('app/db/migrations'))
+let runner = createMigrationRunner(adapter, migrations)
+
+try {
+  let result = direction === 'up' ? await runner.up({ to }) : await runner.down({ to })
+  console.log(direction + ' complete', {
+    applied: result.applied.map((entry) => entry.id),
+    reverted: result.reverted.map((entry) => entry.id),
+  })
+} finally {
+  await pool.end()
+}
+```
+
+Use `journalTable` if you want a custom migrations journal table name:
+
+```ts
+let runner = createMigrationRunner(adapter, migrations, {
+  journalTable: 'app_migrations',
+})
+```
+
+Run it with your runtime, for example:
+
+```sh
+node ./app/db/migrate.ts up
+node ./app/db/migrate.ts up 20260301113000
+node ./app/db/migrate.ts down
+node ./app/db/migrate.ts down 20260228090000
+```
+
+Use `step` when you want bounded rollforward/rollback behavior instead of a target id:
+
+```ts
+await runner.up({ step: 1 })
+await runner.down({ step: 1 })
+```
+
+`to` and `step` are mutually exclusive. Use one or the other for a given run.
+
+Use `dryRun` to compile and inspect the SQL plan without applying migrations:
+
+```ts
+let dryRunResult = await runner.up({ dryRun: true })
+console.log(dryRunResult.sql)
+```
+
+When migration transactions are enabled, migration-time `schema.createTable(...)`, `db.exec(...)`,
+query-builder data operations, and `schema.hasTable(...)` / `schema.hasColumn(...)` all run in the same
+adapter transaction context.
+
+You can also pass a pre-built SQL statement into `schema.plan(...)` when authoring migrations:
+
+```ts
+import { sql } from 'remix/data-table'
+
+await schema.plan(sql`update users set status = ${'active'} where status is null`)
+```
+
+You can run lightweight schema checks inside a migration with `schema.hasTable(...)` and
+`schema.hasColumn(...)` when you need defensive conditional behavior. Methods that take a table name
+accept either a string (`'app.users'`) or a `table(...)` object.
+
+In `dryRun` mode, introspection methods still check the live database state. They do not simulate
+tables/columns from pending operations in the current dry-run plan.
+
+For key-oriented migration APIs, single-column and compound forms are both supported:
+
+```ts
+await schema.alterTable(users, (table) => {
+  table.addPrimaryKey('id')
+  table.addForeignKey('account_id', 'accounts', 'id')
+  table.addForeignKey(['tenant_id', 'account_id'], 'accounts', ['tenant_id', 'id'])
+})
+```
+
+Constraint and index names are optional in migration APIs. When omitted, `data-table` generates
+deterministic names for primary keys, uniques, foreign keys, checks, and indexes.
+
+This is useful when you want to:
+
+- Review generated SQL in CI before deploying
+- Verify migration ordering and target/step selection
+- Audit dialect-specific SQL differences across adapters
+
+For non-filesystem runtimes, register migrations manually:
+
+```ts
+import { createMigrationRegistry, createMigrationRunner } from 'remix/data-table/migrations'
+import createUsers from './db/migrations/20260228090000_create_users.ts'
+
+let registry = createMigrationRegistry()
+registry.register({ id: '20260228090000', name: 'create_users', migration: createUsers })
+
+// adapter from createPostgresDatabaseAdapter/createMysqlDatabaseAdapter/createSqliteDatabaseAdapter
+let runner = createMigrationRunner(adapter, registry)
+await runner.up()
+```
+
 ## Raw SQL Escape Hatch
 
 ```ts
@@ -287,9 +520,27 @@ await db.exec(sql`select * from users where id = ${'u_001'}`)
 await db.exec(rawSql('update users set role = ? where id = ?', ['admin', 'u_001']))
 ```
 
+Use `sql` when you need raw SQL plus safe value interpolation:
+
+```ts
+import { sql } from 'remix/data-table'
+
+let email = input.email
+let minCreatedAt = input.minCreatedAt
+
+let result = await db.exec(sql`
+  select id, email
+  from users
+  where email = ${email}
+    and created_at >= ${minCreatedAt}
+`)
+```
+
+`sql` keeps values parameterized per adapter dialect, so you can avoid manual string concatenation.
+
 ## Related Packages
 
-- [`data-schema`](https://github.com/remix-run/remix/tree/main/packages/data-schema) - Schema definitions and parsing used by `data-table`
+- [`data-schema`](https://github.com/remix-run/remix/tree/main/packages/data-schema) - Optional schema parsing you can use inside table-level `validate(...)` hooks
 - [`data-table-postgres`](https://github.com/remix-run/remix/tree/main/packages/data-table-postgres) - PostgreSQL adapter
 - [`data-table-mysql`](https://github.com/remix-run/remix/tree/main/packages/data-table-mysql) - MySQL adapter
 - [`data-table-sqlite`](https://github.com/remix-run/remix/tree/main/packages/data-table-sqlite) - SQLite adapter

package/dist/index.d.ts

@@ -1,11 +1,15 @@
-export type { AdapterCapabilityOverrides, AdapterCapabilities, AdapterExecuteRequest, AdapterResult, AdapterStatement, DatabaseAdapter, TransactionOptions, TransactionToken, } from './lib/adapter.ts';
+export type { AdapterCapabilityOverrides, AdapterCapabilities, DataManipulationRequest, DataMigrationRequest, AddCheckChange, AddCheckOperation, AddColumnChange, AddForeignKeyChange, AddForeignKeyOperation, AddPrimaryKeyChange, AddUniqueChange, AlterTableChange, AlterTableOperation, ChangeColumnChange, CheckConstraint, ColumnCheck, ColumnComputed, ColumnDefault, ColumnDefinition, ColumnTypeName, CountOperation, CreateIndexOperation, CreateTableOperation, DataMigrationResult, DataMigrationOperation, DataManipulationResult, DataManipulationOperation, DeleteOperation, DatabaseAdapter, DropCheckChange, DropCheckOperation, DropColumnChange, DropForeignKeyChange, DropForeignKeyOperation, DropIndexOperation, DropPrimaryKeyChange, DropTableOperation, DropUniqueChange, ExistsOperation, ForeignKeyAction, ForeignKeyConstraint, IndexDefinition, IndexMethod, InsertManyOperation, InsertOperation, JoinClause, JoinType, PrimaryKeyConstraint, RawOperation, RenameColumnChange, RenameIndexOperation, RenameTableOperation, ReturningSelection, SelectColumn, SelectOperation, SetTableCommentChange, TableRef, TransactionOptions, TransactionToken, UniqueConstraint, UpdateOperation, UpsertOperation, } from './lib/adapter.ts';
 export { DataTableAdapterError, DataTableConstraintError, DataTableError, DataTableQueryError, DataTableValidationError, } from './lib/errors.ts';
-export type { AnyRelation, AnyColumn, AnyTable, BelongsToOptions, ColumnReference, ColumnReferenceForQualifiedName, ColumnSchemas, HasManyOptions, HasManyThroughOptions, HasOneOptions, KeySelector, OrderByClause, OrderDirection, PrimaryKeyInput, Relation, RelationCardinality, RelationKind, RelationMapForTable, Table, TableColumnInput, TableColumnName, TableColumns, TableName, TablePrimaryKey, TableReference, TableRow, TableRowWith, TimestampConfig, TimestampOptions, } from './lib/table.ts';
-export { belongsTo, columnMetadataKey, createTable, getTableColumns, getTableName, getTablePrimaryKey, getTableReference, getTableTimestamps, hasMany, hasManyThrough, hasOne, tableMetadataKey, timestampSchema, timestamps, } from './lib/table.ts';
+export type { AnyRelation, AnyColumn, AnyTable, BelongsToOptions, ColumnReference, ColumnReferenceForQualifiedName, HasManyOptions, HasManyThroughOptions, HasOneOptions, KeySelector, OrderByClause, OrderDirection, PrimaryKeyInput, Relation, RelationCardinality, RelationKind, RelationMapForTable, Table, TableAfterDelete, TableAfterDeleteContext, TableAfterRead, TableAfterReadContext, TableAfterReadResult, TableAfterWrite, TableAfterWriteContext, TableBeforeDelete, TableBeforeDeleteContext, TableBeforeDeleteResult, TableBeforeWrite, TableBeforeWriteContext, TableBeforeWriteResult, TableColumnInput, TableColumnName, TableColumns, TableLifecycleOperation, TableName, TablePrimaryKey, TableReference, TableRow, TableRowWith, TableColumnsDefinition, TableValidate, TableValidationContext, TableWriteOperation, TableValidationOperation, TableValidationResult, TimestampConfig, TimestampOptions, ValidationFailure, ValidationIssue, } from './lib/table.ts';
+export { belongsTo, columnMetadataKey, fail, getTableColumns, getTableColumnDefinitions, getTableBeforeDelete, getTableBeforeWrite, getTableAfterDelete, getTableAfterRead, getTableAfterWrite, getTableName, getTablePrimaryKey, getTableReference, getTableTimestamps, getTableValidator, hasMany, hasManyThrough, hasOne, table, tableMetadataKey, timestamps, } from './lib/table.ts';
+export type { ColumnNamespace } from './lib/column.ts';
+export { ColumnBuilder, column } from './lib/column.ts';
 export type { Predicate, WhereInput, WhereObject } from './lib/operators.ts';
 export { and, between, eq, gt, gte, ilike, inList, isNull, like, lt, lte, ne, notInList, notNull, or, } from './lib/operators.ts';
 export type { SqlStatement } from './lib/sql.ts';
 export { rawSql, sql } from './lib/sql.ts';
-export type { CountOptions, CreateManyResultOptions, CreateManyRowsOptions, CreateResultOptions, CreateRowOptions, Database, DeleteManyOptions, FindManyOptions, FindOneOptions, OrderByInput, OrderByTuple, QueryBuilderFor, QueryColumnTypesForTable, QueryForTable, QueryMethod, QueryTableInput, SingleTableColumn, SingleTableWhere, UpdateManyOptions, UpdateOptions, WriteResult, WriteRowResult, WriteRowsResult, } from './lib/database.ts';
-export { createDatabase, QueryBuilder } from './lib/database.ts';
+export type { CountOptions, CreateManyResultOptions, CreateManyRowsOptions, CreateResultOptions, CreateRowOptions, DeleteManyOptions, FindManyOptions, FindOneOptions, OrderByInput, OrderByTuple, QueryColumnTypesForTable, QueryForTable, QueryTableInput, SingleTableColumn, SingleTableWhere, UpdateManyOptions, UpdateOptions, WriteResult, WriteRowResult, WriteRowsResult, } from './lib/database.ts';
+export { createDatabase, Database } from './lib/database.ts';
+export type { AnyQuery } from './lib/query.ts';
+export { Query, query } from './lib/query.ts';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,0BAA0B,EAC1B,mBAAmB,EACnB,qBAAqB,EACrB,aAAa,EACb,gBAAgB,EAChB,eAAe,EACf,kBAAkB,EAClB,gBAAgB,GACjB,MAAM,kBAAkB,CAAA;AAEzB,OAAO,EACL,qBAAqB,EACrB,wBAAwB,EACxB,cAAc,EACd,mBAAmB,EACnB,wBAAwB,GACzB,MAAM,iBAAiB,CAAA;AAExB,YAAY,EACV,WAAW,EACX,SAAS,EACT,QAAQ,EACR,gBAAgB,EAChB,eAAe,EACf,+BAA+B,EAC/B,aAAa,EACb,cAAc,EACd,qBAAqB,EACrB,aAAa,EACb,WAAW,EACX,aAAa,EACb,cAAc,EACd,eAAe,EACf,QAAQ,EACR,mBAAmB,EACnB,YAAY,EACZ,mBAAmB,EACnB,KAAK,EACL,gBAAgB,EAChB,eAAe,EACf,YAAY,EACZ,SAAS,EACT,eAAe,EACf,cAAc,EACd,QAAQ,EACR,YAAY,EACZ,eAAe,EACf,gBAAgB,GACjB,MAAM,gBAAgB,CAAA;AACvB,OAAO,EACL,SAAS,EACT,iBAAiB,EACjB,WAAW,EACX,eAAe,EACf,YAAY,EACZ,kBAAkB,EAClB,iBAAiB,EACjB,kBAAkB,EAClB,OAAO,EACP,cAAc,EACd,MAAM,EACN,gBAAgB,EAChB,eAAe,EACf,UAAU,GACX,MAAM,gBAAgB,CAAA;AAEvB,YAAY,EAAE,SAAS,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAA;AAC5E,OAAO,EACL,GAAG,EACH,OAAO,EACP,EAAE,EACF,EAAE,EACF,GAAG,EACH,KAAK,EACL,MAAM,EACN,MAAM,EACN,IAAI,EACJ,EAAE,EACF,GAAG,EACH,EAAE,EACF,SAAS,EACT,OAAO,EACP,EAAE,GACH,MAAM,oBAAoB,CAAA;AAE3B,YAAY,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AAChD,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,cAAc,CAAA;AAE1C,YAAY,EACV,YAAY,EACZ,uBAAuB,EACvB,qBAAqB,EACrB,mBAAmB,EACnB,gBAAgB,EAChB,QAAQ,EACR,iBAAiB,EACjB,eAAe,EACf,cAAc,EACd,YAAY,EACZ,YAAY,EACZ,eAAe,EACf,wBAAwB,EACxB,aAAa,EACb,WAAW,EACX,eAAe,EACf,iBAAiB,EACjB,gBAAgB,EAChB,iBAAiB,EACjB,aAAa,EACb,WAAW,EACX,cAAc,EACd,eAAe,GAChB,MAAM,mBAAmB,CAAA;AAC1B,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/index.js

@@ -1,5 +1,7 @@
 export { DataTableAdapterError, DataTableConstraintError, DataTableError, DataTableQueryError, DataTableValidationError, } from "./lib/errors.js";
-export { belongsTo, columnMetadataKey, createTable, getTableColumns, getTableName, getTablePrimaryKey, getTableReference, getTableTimestamps, hasMany, hasManyThrough, hasOne, tableMetadataKey, timestampSchema, timestamps, } from "./lib/table.js";
+export { belongsTo, columnMetadataKey, fail, getTableColumns, getTableColumnDefinitions, getTableBeforeDelete, getTableBeforeWrite, getTableAfterDelete, getTableAfterRead, getTableAfterWrite, getTableName, getTablePrimaryKey, getTableReference, getTableTimestamps, getTableValidator, hasMany, hasManyThrough, hasOne, table, tableMetadataKey, timestamps, } from "./lib/table.js";
+export { ColumnBuilder, column } from "./lib/column.js";
 export { and, between, eq, gt, gte, ilike, inList, isNull, like, lt, lte, ne, notInList, notNull, or, } from "./lib/operators.js";
 export { rawSql, sql } from "./lib/sql.js";
-export { createDatabase, QueryBuilder } from "./lib/database.js";
+export { createDatabase, Database } from "./lib/database.js";
+export { Query, query } from "./lib/query.js";