@avelonjs/postgres 0.1.0 → 0.3.1

package/src/fixtures.ts

@@ -1,57 +1,7 @@
 import type { SQL } from 'bun'
+import { ASSAY_FIXTURE_SQL } from './fixtures-sql'
 
-/** SQL that drops and recreates the database conformance fixtures. */
-export const ASSAY_FIXTURE_SQL = `
-DROP TABLE IF EXISTS assay_reactions CASCADE;
-DROP TABLE IF EXISTS assay_comments CASCADE;
-DROP TABLE IF EXISTS assay_posts CASCADE;
-DROP TABLE IF EXISTS assay_profiles CASCADE;
-DROP TABLE IF EXISTS assay_users CASCADE;
-DROP FUNCTION IF EXISTS assay_echo(jsonb);
-
-CREATE TABLE assay_users (
-  id text PRIMARY KEY,
-  email text NOT NULL UNIQUE,
-  name text NOT NULL,
-  age integer NOT NULL,
-  nickname text
-);
-
-CREATE TABLE assay_profiles (
-  id text PRIMARY KEY,
-  user_id text NOT NULL UNIQUE REFERENCES assay_users(id) ON DELETE CASCADE,
-  bio text NOT NULL
-);
-
-CREATE TABLE assay_posts (
-  id text PRIMARY KEY,
-  user_id text NOT NULL REFERENCES assay_users(id) ON DELETE CASCADE,
-  title text NOT NULL,
-  score integer NOT NULL,
-  published_at timestamptz
-);
-
-CREATE TABLE assay_comments (
-  id text PRIMARY KEY,
-  post_id text NOT NULL REFERENCES assay_posts(id) ON DELETE CASCADE,
-  body text NOT NULL,
-  position integer NOT NULL
-);
-
-CREATE TABLE assay_reactions (
-  id text PRIMARY KEY,
-  comment_id text NOT NULL REFERENCES assay_comments(id) ON DELETE CASCADE,
-  kind text NOT NULL
-);
-
-CREATE OR REPLACE FUNCTION assay_echo(args jsonb)
-RETURNS jsonb
-LANGUAGE sql
-IMMUTABLE
-AS $$
-  SELECT args;
-$$;
-`
+export { ASSAY_FIXTURE_SQL, ASSAY_FIXTURE_STATEMENTS } from './fixtures-sql'
 
 /** Provisions empty assay fixture tables and the `assay_echo` routine. */
 export async function resetAssayFixtures(sql: SQL): Promise<void> {

package/src/index.ts

@@ -1,3 +1,4 @@
+export { bunSqlRunner } from './bun-client'
 export { compilePostgres, compileSqlPredicate, type CompiledSql } from './compile'
 export {
   createPostgresDatabase,
@@ -6,7 +7,7 @@ export {
   type PostgresDatabaseOptions,
 } from './driver'
 export { mapPostgresError, POSTGRES_ERROR_MAP } from './errors'
-export { ASSAY_FIXTURE_SQL, resetAssayFixtures } from './fixtures'
+export { ASSAY_FIXTURE_SQL, ASSAY_FIXTURE_STATEMENTS, resetAssayFixtures } from './fixtures'
 export {
   applyMigrations,
   planMigrations,

package/src/migrations-core.ts

@@ -0,0 +1,142 @@
+import type { MigrationPlan, MigrationStatus } from '@avelonjs/core'
+import type { CompiledSql } from './compile'
+import { mapPostgresError } from './errors'
+import type { SqlBatchRunner, SqlRunner } from './sql-client'
+
+/** One driver-owned SQL migration pair. */
+export interface PostgresMigration {
+  /** Stable migration identifier. */
+  id: string
+  /** Statements applied in order. */
+  up: readonly string[]
+  /** Statements used to roll the migration back. */
+  down: readonly string[]
+}
+
+const HISTORY_TABLE = 'avelon_migrations'
+
+function statement(text: string, parameters: unknown[] = []): CompiledSql {
+  return { text, parameters }
+}
+
+function asDate(value: unknown): Date | undefined {
+  if (value instanceof Date) return value
+  if (typeof value === 'string' || typeof value === 'number') {
+    const parsed = new Date(value)
+    return Number.isNaN(parsed.getTime()) ? undefined : parsed
+  }
+  return undefined
+}
+
+async function ensureHistory(runner: SqlRunner): Promise<void> {
+  try {
+    await runner.unsafe(`
+      CREATE TABLE IF NOT EXISTS ${HISTORY_TABLE} (
+        id text PRIMARY KEY,
+        applied_at timestamptz NOT NULL DEFAULT now()
+      )
+    `)
+  } catch (error) {
+    mapPostgresError(error, 'migrations.ensureHistory')
+  }
+}
+
+async function appliedIds(runner: SqlRunner): Promise<Set<string>> {
+  await ensureHistory(runner)
+  try {
+    const result = await runner.unsafe(`SELECT id FROM ${HISTORY_TABLE}`)
+    return new Set(result.rows.map((row) => String(row.id)))
+  } catch (error) {
+    mapPostgresError(error, 'migrations.status')
+  }
+}
+
+/** Builds a pending migration plan from registered migrations and history. */
+export async function planMigrations(
+  runner: SqlRunner,
+  migrations: readonly PostgresMigration[],
+): Promise<MigrationPlan> {
+  const applied = await appliedIds(runner)
+  const pending = migrations.filter((migration) => !applied.has(migration.id))
+  return {
+    id: `postgres-${pending.map((migration) => migration.id).join('+') || 'empty'}`,
+    migrations: pending.map((migration) => migration.id),
+    steps: pending.flatMap((migration) => migration.up),
+  }
+}
+
+/**
+ * Applies every pending migration and returns the resulting statuses.
+ *
+ * Each migration's statements and its history row are known before the batch starts, so the whole
+ * migration reaches the runner as one atomic statement list.
+ */
+export async function applyMigrations(
+  runner: SqlBatchRunner,
+  migrations: readonly PostgresMigration[],
+): Promise<readonly MigrationStatus[]> {
+  const plan = await planMigrations(runner, migrations)
+  for (const id of plan.migrations) {
+    const migration = migrations.find((entry) => entry.id === id)
+    if (migration === undefined) continue
+    try {
+      await runner.batch([
+        ...migration.up.map((text) => statement(text)),
+        statement(`INSERT INTO ${HISTORY_TABLE} (id) VALUES ($1)`, [id]),
+      ])
+    } catch (error) {
+      mapPostgresError(error, 'migrations.apply')
+    }
+  }
+  return statusMigrations(runner, migrations)
+}
+
+/** Rolls back the newest applied migration batches. */
+export async function rollbackMigrations(
+  runner: SqlBatchRunner,
+  migrations: readonly PostgresMigration[],
+  steps = 1,
+): Promise<readonly MigrationStatus[]> {
+  await ensureHistory(runner)
+  const count = Number.isInteger(steps) && steps > 0 ? steps : 1
+  try {
+    const applied = await runner.unsafe(
+      `SELECT id, applied_at FROM ${HISTORY_TABLE} ORDER BY applied_at DESC LIMIT $1`,
+      [count],
+    )
+
+    for (const row of applied.rows) {
+      const id = String(row.id)
+      const migration = migrations.find((entry) => entry.id === id)
+      if (migration === undefined) continue
+      await runner.batch([
+        ...migration.down.map((text) => statement(text)),
+        statement(`DELETE FROM ${HISTORY_TABLE} WHERE id = $1`, [id]),
+      ])
+    }
+  } catch (error) {
+    mapPostgresError(error, 'migrations.rollback')
+  }
+  return statusMigrations(runner, migrations)
+}
+
+/** Returns applied/pending status for every registered migration. */
+export async function statusMigrations(
+  runner: SqlRunner,
+  migrations: readonly PostgresMigration[],
+): Promise<readonly MigrationStatus[]> {
+  await ensureHistory(runner)
+  try {
+    const result = await runner.unsafe(`SELECT id, applied_at FROM ${HISTORY_TABLE}`)
+    const byId = new Map(result.rows.map((row) => [String(row.id), asDate(row.applied_at)]))
+    return migrations.map((migration) => {
+      if (!byId.has(migration.id)) return { id: migration.id, applied: false }
+      const appliedAt = byId.get(migration.id)
+      return appliedAt === undefined
+        ? { id: migration.id, applied: true }
+        : { id: migration.id, applied: true, appliedAt }
+    })
+  } catch (error) {
+    mapPostgresError(error, 'migrations.status')
+  }
+}

package/src/migrations.ts

@@ -1,54 +1,22 @@
 import type { SQL } from 'bun'
 import type { MigrationPlan, MigrationStatus } from '@avelonjs/core'
-import { mapPostgresError } from './errors'
+import { bunSqlRunner } from './bun-client'
+import {
+  applyMigrations as applyMigrationsCore,
+  planMigrations as planMigrationsCore,
+  rollbackMigrations as rollbackMigrationsCore,
+  statusMigrations as statusMigrationsCore,
+  type PostgresMigration,
+} from './migrations-core'
 
-/** One driver-owned SQL migration pair. */
-export interface PostgresMigration {
-  /** Stable migration identifier. */
-  id: string
-  /** Statements applied in order. */
-  up: readonly string[]
-  /** Statements used to roll the migration back. */
-  down: readonly string[]
-}
-
-const HISTORY_TABLE = 'avelon_migrations'
-
-async function ensureHistory(sql: SQL): Promise<void> {
-  try {
-    await sql.unsafe(`
-      CREATE TABLE IF NOT EXISTS ${HISTORY_TABLE} (
-        id text PRIMARY KEY,
-        applied_at timestamptz NOT NULL DEFAULT now()
-      )
-    `)
-  } catch (error) {
-    mapPostgresError(error, 'migrations.ensureHistory')
-  }
-}
-
-async function appliedIds(sql: SQL): Promise<Set<string>> {
-  await ensureHistory(sql)
-  try {
-    const rows = (await sql.unsafe(`SELECT id FROM ${HISTORY_TABLE}`)) as Array<{ id: string }>
-    return new Set(rows.map((row) => row.id))
-  } catch (error) {
-    mapPostgresError(error, 'migrations.status')
-  }
-}
+export type { PostgresMigration } from './migrations-core'
 
 /** Builds a pending migration plan from registered migrations and history. */
 export async function planMigrations(
   sql: SQL,
   migrations: readonly PostgresMigration[],
 ): Promise<MigrationPlan> {
-  const applied = await appliedIds(sql)
-  const pending = migrations.filter((migration) => !applied.has(migration.id))
-  return {
-    id: `postgres-${pending.map((migration) => migration.id).join('+') || 'empty'}`,
-    migrations: pending.map((migration) => migration.id),
-    steps: pending.flatMap((migration) => migration.up),
-  }
+  return planMigrationsCore(bunSqlRunner(sql), migrations)
 }
 
 /** Applies every pending migration and returns the resulting statuses. */
@@ -56,20 +24,7 @@ export async function applyMigrations(
   sql: SQL,
   migrations: readonly PostgresMigration[],
 ): Promise<readonly MigrationStatus[]> {
-  const plan = await planMigrations(sql, migrations)
-  for (const id of plan.migrations) {
-    const migration = migrations.find((entry) => entry.id === id)
-    if (migration === undefined) continue
-    try {
-      await sql.begin(async (tx) => {
-        for (const statement of migration.up) await tx.unsafe(statement)
-        await tx.unsafe(`INSERT INTO ${HISTORY_TABLE} (id) VALUES ($1)`, [id])
-      })
-    } catch (error) {
-      mapPostgresError(error, 'migrations.apply')
-    }
-  }
-  return statusMigrations(sql, migrations)
+  return applyMigrationsCore(bunSqlRunner(sql), migrations)
 }
 
 /** Rolls back the newest applied migration batches. */
@@ -78,26 +33,7 @@ export async function rollbackMigrations(
   migrations: readonly PostgresMigration[],
   steps = 1,
 ): Promise<readonly MigrationStatus[]> {
-  await ensureHistory(sql)
-  const count = Number.isInteger(steps) && steps > 0 ? steps : 1
-  try {
-    const applied = (await sql.unsafe(
-      `SELECT id, applied_at FROM ${HISTORY_TABLE} ORDER BY applied_at DESC LIMIT $1`,
-      [count],
-    )) as Array<{ id: string; applied_at: Date }>
-
-    for (const row of applied) {
-      const migration = migrations.find((entry) => entry.id === row.id)
-      if (migration === undefined) continue
-      await sql.begin(async (tx) => {
-        for (const statement of migration.down) await tx.unsafe(statement)
-        await tx.unsafe(`DELETE FROM ${HISTORY_TABLE} WHERE id = $1`, [row.id])
-      })
-    }
-  } catch (error) {
-    mapPostgresError(error, 'migrations.rollback')
-  }
-  return statusMigrations(sql, migrations)
+  return rollbackMigrationsCore(bunSqlRunner(sql), migrations, steps)
 }
 
 /** Returns applied/pending status for every registered migration. */
@@ -105,19 +41,5 @@ export async function statusMigrations(
   sql: SQL,
   migrations: readonly PostgresMigration[],
 ): Promise<readonly MigrationStatus[]> {
-  await ensureHistory(sql)
-  try {
-    const rows = (await sql.unsafe(
-      `SELECT id, applied_at FROM ${HISTORY_TABLE}`,
-    )) as Array<{ id: string; applied_at: Date }>
-    const byId = new Map(rows.map((row) => [row.id, row.applied_at]))
-    return migrations.map((migration) => {
-      const appliedAt = byId.get(migration.id)
-      return appliedAt === undefined
-        ? { id: migration.id, applied: false }
-        : { id: migration.id, applied: true, appliedAt }
-    })
-  } catch (error) {
-    mapPostgresError(error, 'migrations.status')
-  }
+  return statusMigrationsCore(bunSqlRunner(sql), migrations)
 }

package/src/schema-core.ts

@@ -0,0 +1,124 @@
+import { Invalid, type QueryIR, type RelationLoad } from '@avelonjs/core'
+import { mapPostgresError } from './errors'
+import type { SqlRunner } from './sql-client'
+
+/** Cached public-schema column sets keyed by table name. */
+export type SchemaCache = Map<string, Set<string>>
+
+/** Loads every public base table and its columns through any SQL runner. */
+export async function loadSchemaCache(runner: SqlRunner): Promise<SchemaCache> {
+  try {
+    const result = await runner.unsafe(`
+      SELECT table_name, column_name
+      FROM information_schema.columns
+      WHERE table_schema = 'public'
+      ORDER BY table_name, ordinal_position
+    `)
+
+    const cache: SchemaCache = new Map()
+    for (const row of result.rows) {
+      const table = String(row.table_name)
+      const columns = cache.get(table) ?? new Set<string>()
+      columns.add(String(row.column_name))
+      cache.set(table, columns)
+    }
+    return cache
+  } catch (error) {
+    mapPostgresError(error, 'schema.load')
+  }
+}
+
+function invalid(message: string, field: string, detail: string): never {
+  throw new Invalid(message, { metadata: { fields: { [field]: [detail] } } })
+}
+
+function assertTable(cache: SchemaCache, table: string, field: string): Set<string> {
+  const columns = cache.get(table)
+  if (columns === undefined) {
+    invalid(`Unknown table ${table}.`, field, 'Unknown identifier')
+  }
+  return columns
+}
+
+function assertColumn(columns: Set<string>, table: string, column: string, field: string): void {
+  if (!columns.has(column)) {
+    invalid(`Unknown column ${column} on ${table}.`, field, `Unknown identifier: ${column}`)
+  }
+}
+
+function assertProjection(
+  columns: Set<string>,
+  table: string,
+  projection: string[] | '*',
+  field: string,
+): void {
+  if (projection === '*') return
+  for (const column of projection) assertColumn(columns, table, column, field)
+}
+
+function assertRelation(cache: SchemaCache, parentTable: string, relation: RelationLoad): void {
+  const parentColumns = assertTable(cache, parentTable, 'relations')
+  assertColumn(parentColumns, parentTable, relation.localKey, 'relations')
+  const relatedColumns = assertTable(cache, relation.table, 'relations')
+  assertColumn(relatedColumns, relation.table, relation.foreignKey, 'relations')
+  assertProjection(relatedColumns, relation.table, relation.select, 'relations')
+  for (const term of relation.order) {
+    assertColumn(relatedColumns, relation.table, term.column, 'relations')
+  }
+  for (const nested of relation.relations) assertRelation(cache, relation.table, nested)
+}
+
+/**
+ * Rejects unknown tables and columns before a statement is sent.
+ *
+ * Needed so empty parent row sets cannot skip a relation table that does not exist.
+ */
+export function assertQueryAgainstSchema(cache: SchemaCache, query: QueryIR): void {
+  const columns = assertTable(cache, query.table, 'table')
+  assertProjection(columns, query.table, query.select, 'select')
+  if (query.returning !== undefined) {
+    assertProjection(columns, query.table, query.returning, 'returning')
+  }
+  for (const term of query.order) assertColumn(columns, query.table, term.column, 'order')
+
+  const checkPredicateColumns = (predicate: QueryIR['where'][number]): void => {
+    switch (predicate.kind) {
+      case 'compare':
+      case 'null':
+      case 'in':
+        assertColumn(columns, query.table, predicate.column, 'where')
+        return
+      case 'and':
+      case 'or':
+        predicate.predicates.forEach(checkPredicateColumns)
+        return
+      case 'not':
+        checkPredicateColumns(predicate.predicate)
+        return
+      case 'const':
+        return
+    }
+  }
+  query.where.forEach(checkPredicateColumns)
+  if (query.ward) checkPredicateColumns(query.ward)
+
+  if (query.values !== undefined) {
+    const rows = Array.isArray(query.values) ? query.values : [query.values]
+    for (const row of rows) {
+      for (const column of Object.keys(row)) assertColumn(columns, query.table, column, 'values')
+    }
+  }
+
+  if (query.conflict !== undefined) {
+    for (const column of query.conflict.columns) {
+      assertColumn(columns, query.table, column, 'conflict')
+    }
+    if (query.conflict.update !== '*') {
+      for (const column of query.conflict.update) {
+        assertColumn(columns, query.table, column, 'conflict')
+      }
+    }
+  }
+
+  for (const relation of query.relations) assertRelation(cache, query.table, relation)
+}

package/src/schema.ts

@@ -1,123 +1,11 @@
 import type { SQL } from 'bun'
-import { Invalid, type QueryIR, type RelationLoad } from '@avelonjs/core'
-import { mapPostgresError } from './errors'
+import { bunSqlRunner } from './bun-client'
+import { loadSchemaCache as loadSchemaCacheCore, type SchemaCache } from './schema-core'
 
-/** Cached public-schema column sets keyed by table name. */
-export type SchemaCache = Map<string, Set<string>>
+export { assertQueryAgainstSchema } from './schema-core'
+export type { SchemaCache } from './schema-core'
 
 /** Loads every public base table and its columns. */
 export async function loadSchemaCache(sql: SQL): Promise<SchemaCache> {
-  try {
-    const rows = (await sql.unsafe(`
-      SELECT table_name, column_name
-      FROM information_schema.columns
-      WHERE table_schema = 'public'
-      ORDER BY table_name, ordinal_position
-    `)) as Array<{ table_name: string; column_name: string }>
-
-    const cache: SchemaCache = new Map()
-    for (const row of rows) {
-      const columns = cache.get(row.table_name) ?? new Set<string>()
-      columns.add(row.column_name)
-      cache.set(row.table_name, columns)
-    }
-    return cache
-  } catch (error) {
-    mapPostgresError(error, 'schema.load')
-  }
-}
-
-function invalid(message: string, field: string, detail: string): never {
-  throw new Invalid(message, { metadata: { fields: { [field]: [detail] } } })
-}
-
-function assertTable(cache: SchemaCache, table: string, field: string): Set<string> {
-  const columns = cache.get(table)
-  if (columns === undefined) {
-    invalid(`Unknown table ${table}.`, field, 'Unknown identifier')
-  }
-  return columns
-}
-
-function assertColumn(columns: Set<string>, table: string, column: string, field: string): void {
-  if (!columns.has(column)) {
-    invalid(`Unknown column ${column} on ${table}.`, field, `Unknown identifier: ${column}`)
-  }
-}
-
-function assertProjection(
-  columns: Set<string>,
-  table: string,
-  projection: string[] | '*',
-  field: string,
-): void {
-  if (projection === '*') return
-  for (const column of projection) assertColumn(columns, table, column, field)
-}
-
-function assertRelation(cache: SchemaCache, parentTable: string, relation: RelationLoad): void {
-  const parentColumns = assertTable(cache, parentTable, 'relations')
-  assertColumn(parentColumns, parentTable, relation.localKey, 'relations')
-  const relatedColumns = assertTable(cache, relation.table, 'relations')
-  assertColumn(relatedColumns, relation.table, relation.foreignKey, 'relations')
-  assertProjection(relatedColumns, relation.table, relation.select, 'relations')
-  for (const term of relation.order) {
-    assertColumn(relatedColumns, relation.table, term.column, 'relations')
-  }
-  for (const nested of relation.relations) assertRelation(cache, relation.table, nested)
-}
-
-/**
- * Rejects unknown tables and columns before a statement is sent.
- *
- * Needed so empty parent row sets cannot skip a relation table that does not exist.
- */
-export function assertQueryAgainstSchema(cache: SchemaCache, query: QueryIR): void {
-  const columns = assertTable(cache, query.table, 'table')
-  assertProjection(columns, query.table, query.select, 'select')
-  if (query.returning !== undefined) {
-    assertProjection(columns, query.table, query.returning, 'returning')
-  }
-  for (const term of query.order) assertColumn(columns, query.table, term.column, 'order')
-
-  const checkPredicateColumns = (predicate: QueryIR['where'][number]): void => {
-    switch (predicate.kind) {
-      case 'compare':
-      case 'null':
-      case 'in':
-        assertColumn(columns, query.table, predicate.column, 'where')
-        return
-      case 'and':
-      case 'or':
-        predicate.predicates.forEach(checkPredicateColumns)
-        return
-      case 'not':
-        checkPredicateColumns(predicate.predicate)
-        return
-      case 'const':
-        return
-    }
-  }
-  query.where.forEach(checkPredicateColumns)
-  if (query.ward) checkPredicateColumns(query.ward)
-
-  if (query.values !== undefined) {
-    const rows = Array.isArray(query.values) ? query.values : [query.values]
-    for (const row of rows) {
-      for (const column of Object.keys(row)) assertColumn(columns, query.table, column, 'values')
-    }
-  }
-
-  if (query.conflict !== undefined) {
-    for (const column of query.conflict.columns) {
-      assertColumn(columns, query.table, column, 'conflict')
-    }
-    if (query.conflict.update !== '*') {
-      for (const column of query.conflict.update) {
-        assertColumn(columns, query.table, column, 'conflict')
-      }
-    }
-  }
-
-  for (const relation of query.relations) assertRelation(cache, query.table, relation)
+  return loadSchemaCacheCore(bunSqlRunner(sql))
 }

package/src/sql-client.ts

@@ -0,0 +1,28 @@
+import type { CompiledSql } from './compile'
+
+/**
+ * Normalized statement result.
+ *
+ * Bun returns an array carrying a non-enumerable `count`; Neon returns `{ rows, rowCount }`. Both
+ * client adapters flatten to this shape so the execution algorithm never inspects a vendor result.
+ */
+export interface SqlRows {
+  /** Rows the statement produced, owned by the caller and safe to mutate. */
+  rows: Record<string, unknown>[]
+  /** Rows the statement affected, used for writes without `RETURNING`. */
+  count: number
+}
+
+/** Statement runner the vendor-neutral query execution needs. */
+export interface SqlRunner {
+  /** Runs one parameterized statement and returns its normalized result. */
+  unsafe(text: string, parameters?: readonly unknown[]): Promise<SqlRows>
+  /** Releases the underlying connection. Absent on a runner that owns none. */
+  close?(): Promise<void>
+}
+
+/** A runner that can also apply a fully known statement list atomically. */
+export interface SqlBatchRunner extends SqlRunner {
+  /** Applies every statement in one transaction, or none of them. */
+  batch(statements: readonly CompiledSql[]): Promise<void>
+}

package/src/sql.ts

@@ -0,0 +1,15 @@
+export { compilePostgres, compileSqlPredicate, type CompiledSql } from './compile'
+export { mapPostgresError, POSTGRES_ERROR_MAP } from './errors'
+export { executeQueryIR, executeRpc, type RoundTripCounter } from './execute'
+export { ASSAY_FIXTURE_SQL, ASSAY_FIXTURE_STATEMENTS } from './fixtures-sql'
+export {
+  applyMigrations,
+  planMigrations,
+  rollbackMigrations,
+  statusMigrations,
+  type PostgresMigration,
+} from './migrations-core'
+export { combinedPredicate, normalizePredicate } from './normalize'
+export { assertQueryAgainstSchema, loadSchemaCache, type SchemaCache } from './schema-core'
+export type { SqlBatchRunner, SqlRows, SqlRunner } from './sql-client'
+export { assertIdentifier, validateQueryIR } from './validate'