@avelonjs/postgres 0.1.0 → 0.3.1

package/src/driver.ts

@@ -5,14 +5,13 @@ import {
   type DatabaseTransaction,
   type MigrationPlan,
   type MigrationStatus,
-  type Predicate,
   type QueryIR,
   type QueryResult,
-  type RelationLoad,
   type TransactionSurface,
 } from '@avelonjs/core'
-import { compilePostgres } from './compile'
+import { bunSqlRunner } from './bun-client'
 import { mapPostgresError } from './errors'
+import { executeQueryIR, executeRpc } from './execute'
 import { resetAssayFixtures } from './fixtures'
 import {
   applyMigrations,
@@ -20,10 +19,9 @@ import {
   rollbackMigrations,
   statusMigrations,
   type PostgresMigration,
-} from './migrations'
-import { combinedPredicate } from './normalize'
-import { assertQueryAgainstSchema, loadSchemaCache, type SchemaCache } from './schema'
-import { validateQueryIR } from './validate'
+} from './migrations-core'
+import { loadSchemaCache, type SchemaCache } from './schema-core'
+import type { SqlBatchRunner } from './sql-client'
 
 /** Exact capability declaration for the Postgres database driver. */
 export const postgresDatabaseCapabilities = {
@@ -48,9 +46,6 @@ export interface PostgresDatabaseOptions {
   migrations?: readonly PostgresMigration[]
 }
 
-type Row = Record<string, unknown>
-type SqlClient = SQL
-
 function defaultUrl(): string {
   return (
     process.env.POSTGRES_URL ??
@@ -59,56 +54,14 @@ function defaultUrl(): string {
   )
 }
 
-function includeColumns(select: string[] | '*', columns: string[]): string[] | '*' {
-  if (select === '*') return '*'
-  return [...new Set([...select, ...columns])]
-}
-
-function projectRow(row: Row, select: string[] | '*', relations: readonly RelationLoad[]): Row {
-  const output: Row = {}
-  const columns =
-    select === '*'
-      ? Object.keys(row).filter((column) => !relations.some((relation) => relation.relation === column))
-      : select
-  for (const column of columns) output[column] = row[column]
-  for (const relation of relations) output[relation.relation] = row[relation.relation]
-  return output
-}
-
-function unique(values: unknown[]): unknown[] {
-  const output: unknown[] = []
-  for (const value of values) {
-    if (!output.some((existing) => sqlEqual(existing, value))) output.push(value)
-  }
-  return output
-}
-
-function sqlEqual(left: unknown, right: unknown): boolean {
-  if (left === null || left === undefined || right === null || right === undefined) return false
-  return left === right
-}
-
-function asRows(result: unknown): Row[] {
-  if (!Array.isArray(result)) return []
-  return result.map((row) => ({ ...(row as Row) }))
-}
-
-function resultCount(result: unknown): number {
-  if (!Array.isArray(result)) return 0
-  const count = Reflect.get(result, 'count')
-  return typeof count === 'number' ? count : result.length
-}
-
 /**
  * Postgres implementation of the frozen database contract.
  *
- * Vendor access stays inside this package through Bun's SQL client. Application code reaches the
- * driver only through the database facade and never imports `bun` SQL APIs.
+ * Vendor access stays inside this package through Bun's SQL client. The query IR algorithm itself
+ * lives in `@avelonjs/postgres/sql`, which no Bun API reaches; this class only adapts the client.
  */
 export class PostgresDatabase
-  implements
-    DatabaseDriver<typeof postgresDatabaseCapabilities, SQL>,
-    TransactionSurface
+  implements DatabaseDriver<typeof postgresDatabaseCapabilities, SQL>, TransactionSurface
 {
   /** Driver implementation name. */
   readonly name = 'postgres'
@@ -120,6 +73,7 @@ export class PostgresDatabase
   readonly capabilities: typeof postgresDatabaseCapabilities
 
   readonly #sql: SQL
+  readonly #runner: SqlBatchRunner
   readonly #migrations: readonly PostgresMigration[]
   #schema: SchemaCache | undefined
   #roundTrips = 0
@@ -130,6 +84,7 @@ export class PostgresDatabase
     this.#migrations = options.migrations ?? []
     this.capabilities = postgresDatabaseCapabilities
     this.#sql = new SQL(options.url ?? defaultUrl())
+    this.#runner = bunSqlRunner(this.#sql)
   }
 
   /** Number of statements that reached Postgres. Used by conformance short-circuit checks. */
@@ -155,7 +110,7 @@ export class PostgresDatabase
 
   /** Compiles and executes one query IR operation. */
   async execute<TRow = Record<string, unknown>>(query: QueryIR): Promise<QueryResult<TRow>> {
-    return this.#execute(this.#sql, query) as Promise<QueryResult<TRow>>
+    return this.#execute(this.#runner, query) as Promise<QueryResult<TRow>>
   }
 
   /** Invokes a named Postgres routine. Missing routines map to `Invalid`. */
@@ -163,37 +118,27 @@ export class PostgresDatabase
     routine: string,
     args: Readonly<Record<string, unknown>>,
   ): Promise<TResult> {
-    try {
-      this.#roundTrips += 1
-      const rows = asRows(
-        await this.#sql.unsafe(`SELECT ${quoteRoutine(routine)}($1::jsonb) AS result`, [
-          JSON.stringify(args),
-        ]),
-      )
-      return decodeJsonResult(rows[0]?.result) as TResult
-    } catch (error) {
-      mapPostgresError(error, 'rpc')
-    }
+    return executeRpc(this.#runner, routine, args, this.#countRoundTrip) as Promise<TResult>
   }
 
   /** Produces the pending migration plan. */
   async plan(): Promise<MigrationPlan> {
-    return planMigrations(this.#sql, this.#migrations)
+    return planMigrations(this.#runner, this.#migrations)
   }
 
   /** Applies pending migrations. */
   async apply(): Promise<readonly MigrationStatus[]> {
-    return applyMigrations(this.#sql, this.#migrations)
+    return applyMigrations(this.#runner, this.#migrations)
   }
 
   /** Rolls back applied migration batches. */
   async rollback(steps?: number): Promise<readonly MigrationStatus[]> {
-    return rollbackMigrations(this.#sql, this.#migrations, steps)
+    return rollbackMigrations(this.#runner, this.#migrations, steps)
   }
 
   /** Returns all migration states. */
   async status(): Promise<readonly MigrationStatus[]> {
-    return statusMigrations(this.#sql, this.#migrations)
+    return statusMigrations(this.#runner, this.#migrations)
   }
 
   /** Runs a callback inside a Postgres transaction. */
@@ -202,25 +147,12 @@ export class PostgresDatabase
   ): Promise<TResult> {
     try {
       return await this.#sql.begin(async (tx) => {
+        const runner = bunSqlRunner(tx as SQL)
         const transaction: DatabaseTransaction = {
           execute: <TRow = Record<string, unknown>>(query: QueryIR) =>
-            this.#execute(tx as SqlClient, query) as Promise<QueryResult<TRow>>,
-          rpc: async <TResultRpc = unknown>(
-            routine: string,
-            args: Readonly<Record<string, unknown>>,
-          ) => {
-            try {
-              this.#roundTrips += 1
-              const rows = asRows(
-                await (tx as SqlClient).unsafe(`SELECT ${quoteRoutine(routine)}($1::jsonb) AS result`, [
-                  JSON.stringify(args),
-                ]),
-              )
-              return decodeJsonResult(rows[0]?.result) as TResultRpc
-            } catch (error) {
-              mapPostgresError(error, 'rpc')
-            }
-          },
+            this.#execute(runner, query) as Promise<QueryResult<TRow>>,
+          rpc: <TResultRpc = unknown>(routine: string, args: Readonly<Record<string, unknown>>) =>
+            executeRpc(runner, routine, args, this.#countRoundTrip) as Promise<TResultRpc>,
         }
         return callback(transaction)
       })
@@ -238,145 +170,23 @@ export class PostgresDatabase
     }
   }
 
-  async #schemaCache(): Promise<SchemaCache> {
-    if (this.#schema === undefined) this.#schema = await loadSchemaCache(this.#sql)
-    return this.#schema
-  }
-
-  async #execute(sql: SqlClient, ir: QueryIR): Promise<QueryResult> {
-    validateQueryIR(ir, this.capabilities.maxRelationDepth)
-    assertQueryAgainstSchema(await this.#schemaCache(), ir)
-    const predicate = combinedPredicate(ir)
-
-    if (predicate.kind === 'const' && !predicate.value) {
-      return ir.mode === 'count' ? { rows: [], affected: 0, count: 0 } : { rows: [], affected: 0 }
-    }
-
-    if ((ir.mode === 'insert' || ir.mode === 'upsert') && predicate.kind !== 'const') {
-      throw new Invalid(`${ir.mode} with a non-constant where or ward has no documented row scope.`, {
-        metadata: { fields: { where: [`${ir.mode} predicates are not documented`] } },
-      })
-    }
-
-    if (ir.mode === 'select') {
-      const primitive: QueryIR = {
-        ...ir,
-        select: includeColumns(
-          ir.select,
-          ir.relations.map((relation) => relation.localKey),
-        ),
-        relations: [],
-      }
-      const rows = await this.#executePrimitive(sql, primitive, predicate)
-      await this.#loadRelations(sql, rows, ir.relations)
-      return {
-        rows: rows.map((row) => projectRow(row, ir.select, ir.relations)),
-        affected: 0,
-      }
-    }
-
-    if (ir.mode === 'count') {
-      const rows = await this.#executePrimitive(sql, ir, predicate)
-      const count = Number(rows[0]?.count ?? 0)
-      return { rows: [], affected: 0, count }
-    }
-
-    const rows = await this.#executePrimitive(sql, ir, predicate)
-    const affected = resultCount(rows)
-    return {
-      rows: ir.returning === undefined ? [] : rows,
-      affected,
-    }
-  }
-
-  async #executePrimitive(sql: SqlClient, ir: QueryIR, predicate: Predicate): Promise<Row[]> {
-    const compiled = compilePostgres(ir, predicate)
-    try {
-      this.#roundTrips += 1
-      const result = await sql.unsafe(compiled.text, compiled.parameters)
-      const rows = asRows(result)
-      // Preserve Bun's statement count for writes without RETURNING (empty row arrays).
-      Object.defineProperty(rows, 'count', {
-        value: resultCount(result),
-        enumerable: false,
-      })
-      return rows
-    } catch (error) {
-      mapPostgresError(error, 'execute')
-    }
+  readonly #countRoundTrip = (): void => {
+    this.#roundTrips += 1
   }
 
-  async #loadRelations(
-    sql: SqlClient,
-    parents: Row[],
-    relations: readonly RelationLoad[],
-  ): Promise<void> {
-    for (const relation of relations) {
-      const keys = unique(
-        parents
-          .map((parent) => parent[relation.localKey])
-          .filter((value) => value !== null && value !== undefined),
-      )
-
-      if (keys.length === 0) {
-        for (const parent of parents) {
-          parent[relation.relation] = relation.kind === 'hasMany' ? [] : null
-        }
-        continue
-      }
-
-      const childSelect = includeColumns(relation.select, [
-        relation.foreignKey,
-        ...relation.relations.map((nested) => nested.localKey),
-      ])
-      const childWhere: Predicate[] = [
-        ...(relation.where === null ? [] : [relation.where]),
-        { kind: 'in', column: relation.foreignKey, values: keys, negated: false },
-      ]
-      const childIR: QueryIR = {
-        table: relation.table,
-        mode: 'select',
-        select: childSelect,
-        where: childWhere,
-        relations: [],
-        order: relation.order,
-      }
-      const predicate = combinedPredicate(childIR)
-      const children =
-        predicate.kind === 'const' && !predicate.value
-          ? []
-          : await this.#executePrimitive(sql, childIR, predicate)
-      await this.#loadRelations(sql, children, relation.relations)
-
-      for (const parent of parents) {
-        const matches = children.filter((child) =>
-          sqlEqual(child[relation.foreignKey], parent[relation.localKey]),
-        )
-        const limited = relation.limit === undefined ? matches : matches.slice(0, relation.limit)
-        const projected = limited.map((child) =>
-          projectRow(child, relation.select, relation.relations),
-        )
-        parent[relation.relation] = relation.kind === 'hasMany' ? projected : (projected[0] ?? null)
-      }
-    }
-  }
-}
-
-function quoteRoutine(routine: string): string {
-  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(routine)) {
-    throw new Invalid('Routine name must be a simple identifier.', {
-      metadata: { fields: { routine: [routine] } },
-    })
+  async #schemaCache(): Promise<SchemaCache> {
+    if (this.#schema === undefined) this.#schema = await loadSchemaCache(this.#runner)
+    return this.#schema
   }
-  return `"${routine}"`
-}
 
-function decodeJsonResult(value: unknown): unknown {
-  if (typeof value !== 'string') return value
-  try {
-    return JSON.parse(value)
-  } catch {
-    return value
+  async #execute(runner: SqlBatchRunner, ir: QueryIR): Promise<QueryResult> {
+    return executeQueryIR(
+      runner,
+      await this.#schemaCache(),
+      ir,
+      this.capabilities.maxRelationDepth,
+      this.#countRoundTrip,
+    )
   }
 }
 

package/src/errors.ts

@@ -23,6 +23,8 @@ function asPostgresError(error: unknown): PostgresErrorLike | undefined {
 function sqlState(error: PostgresErrorLike): string | undefined {
   if (typeof error.errno === 'string') return error.errno
   if (typeof error.errno === 'number') return String(error.errno)
+  // NeonDbError and node-postgres carry SQLSTATE on `code`; Bun carries it on `errno`.
+  if (typeof error.code === 'string') return error.code
   return undefined
 }
 
@@ -34,7 +36,8 @@ function sqlState(error: PostgresErrorLike): string | undefined {
 export function mapPostgresError(error: unknown, operation: string): never {
   const pg = asPostgresError(error)
   const state = pg === undefined ? undefined : sqlState(pg)
-  const message = pg?.message ?? (error instanceof Error ? error.message : 'Postgres driver failure')
+  const message =
+    pg?.message ?? (error instanceof Error ? error.message : 'Postgres driver failure')
 
   if (state === '23505') {
     throw new Conflict(message, {
@@ -96,5 +99,9 @@ export const POSTGRES_ERROR_MAP = [
   { sqlstate: '57P01', framework: 'Unavailable', meaning: 'admin_shutdown' },
   { sqlstate: '57P03', framework: 'Unavailable', meaning: 'cannot_connect_now' },
   { sqlstate: '08006', framework: 'Unavailable', meaning: 'connection_failure' },
-  { sqlstate: '08001', framework: 'Unavailable', meaning: 'sqlclient_unable_to_establish_sqlconnection' },
+  {
+    sqlstate: '08001',
+    framework: 'Unavailable',
+    meaning: 'sqlclient_unable_to_establish_sqlconnection',
+  },
 ] as const

package/src/execute.ts

@@ -0,0 +1,209 @@
+import {
+  Invalid,
+  type Predicate,
+  type QueryIR,
+  type QueryResult,
+  type RelationLoad,
+} from '@avelonjs/core'
+import { compilePostgres } from './compile'
+import { mapPostgresError } from './errors'
+import { combinedPredicate } from './normalize'
+import { assertQueryAgainstSchema, type SchemaCache } from './schema-core'
+import type { SqlRows, SqlRunner } from './sql-client'
+import { validateQueryIR } from './validate'
+
+type Row = Record<string, unknown>
+
+/** Called once per statement so drivers can keep the conformance round-trip counter. */
+export type RoundTripCounter = () => void
+
+function includeColumns(select: string[] | '*', columns: string[]): string[] | '*' {
+  if (select === '*') return '*'
+  return [...new Set([...select, ...columns])]
+}
+
+function projectRow(row: Row, select: string[] | '*', relations: readonly RelationLoad[]): Row {
+  const output: Row = {}
+  const columns =
+    select === '*'
+      ? Object.keys(row).filter(
+          (column) => !relations.some((relation) => relation.relation === column),
+        )
+      : select
+  for (const column of columns) output[column] = row[column]
+  for (const relation of relations) output[relation.relation] = row[relation.relation]
+  return output
+}
+
+function unique(values: unknown[]): unknown[] {
+  const output: unknown[] = []
+  for (const value of values) {
+    if (!output.some((existing) => sqlEqual(existing, value))) output.push(value)
+  }
+  return output
+}
+
+function sqlEqual(left: unknown, right: unknown): boolean {
+  if (left === null || left === undefined || right === null || right === undefined) return false
+  return left === right
+}
+
+function quoteRoutine(routine: string): string {
+  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(routine)) {
+    throw new Invalid('Routine name must be a simple identifier.', {
+      metadata: { fields: { routine: [routine] } },
+    })
+  }
+  return `"${routine}"`
+}
+
+function decodeJsonResult(value: unknown): unknown {
+  if (typeof value !== 'string') return value
+  try {
+    return JSON.parse(value)
+  } catch {
+    return value
+  }
+}
+
+async function executePrimitive(
+  runner: SqlRunner,
+  ir: QueryIR,
+  predicate: Predicate,
+  onRoundTrip: RoundTripCounter,
+): Promise<SqlRows> {
+  const compiled = compilePostgres(ir, predicate)
+  try {
+    onRoundTrip()
+    return await runner.unsafe(compiled.text, compiled.parameters)
+  } catch (error) {
+    mapPostgresError(error, 'execute')
+  }
+}
+
+async function loadRelations(
+  runner: SqlRunner,
+  parents: Row[],
+  relations: readonly RelationLoad[],
+  onRoundTrip: RoundTripCounter,
+): Promise<void> {
+  for (const relation of relations) {
+    const keys = unique(
+      parents
+        .map((parent) => parent[relation.localKey])
+        .filter((value) => value !== null && value !== undefined),
+    )
+
+    if (keys.length === 0) {
+      for (const parent of parents) {
+        parent[relation.relation] = relation.kind === 'hasMany' ? [] : null
+      }
+      continue
+    }
+
+    const childSelect = includeColumns(relation.select, [
+      relation.foreignKey,
+      ...relation.relations.map((nested) => nested.localKey),
+    ])
+    const childWhere: Predicate[] = [
+      ...(relation.where === null ? [] : [relation.where]),
+      { kind: 'in', column: relation.foreignKey, values: keys, negated: false },
+    ]
+    const childIR: QueryIR = {
+      table: relation.table,
+      mode: 'select',
+      select: childSelect,
+      where: childWhere,
+      relations: [],
+      order: relation.order,
+    }
+    const predicate = combinedPredicate(childIR)
+    const children =
+      predicate.kind === 'const' && !predicate.value
+        ? []
+        : (await executePrimitive(runner, childIR, predicate, onRoundTrip)).rows
+    await loadRelations(runner, children, relation.relations, onRoundTrip)
+
+    for (const parent of parents) {
+      const matches = children.filter((child) =>
+        sqlEqual(child[relation.foreignKey], parent[relation.localKey]),
+      )
+      const limited = relation.limit === undefined ? matches : matches.slice(0, relation.limit)
+      const projected = limited.map((child) =>
+        projectRow(child, relation.select, relation.relations),
+      )
+      parent[relation.relation] = relation.kind === 'hasMany' ? projected : (projected[0] ?? null)
+    }
+  }
+}
+
+/**
+ * Validates, compiles, and executes one query IR operation against any SQL runner.
+ *
+ * Relations load application-side: each level reads its parent rows before the child statement is
+ * built, so this needs an interactive runner and cannot be flattened into one batch.
+ */
+export async function executeQueryIR(
+  runner: SqlRunner,
+  schema: SchemaCache,
+  ir: QueryIR,
+  maxRelationDepth: number,
+  onRoundTrip: RoundTripCounter,
+): Promise<QueryResult> {
+  validateQueryIR(ir, maxRelationDepth)
+  assertQueryAgainstSchema(schema, ir)
+  const predicate = combinedPredicate(ir)
+
+  // An insert or upsert has no rows to scope: a ward that refuses its values is an error from
+  // `compilePostgres`, not an empty result, so it must not short-circuit here.
+  const rowScoped = ir.mode !== 'insert' && ir.mode !== 'upsert'
+  if (rowScoped && predicate.kind === 'const' && !predicate.value) {
+    return ir.mode === 'count' ? { rows: [], affected: 0, count: 0 } : { rows: [], affected: 0 }
+  }
+
+  if (ir.mode === 'select') {
+    const primitive: QueryIR = {
+      ...ir,
+      select: includeColumns(
+        ir.select,
+        ir.relations.map((relation) => relation.localKey),
+      ),
+      relations: [],
+    }
+    const result = await executePrimitive(runner, primitive, predicate, onRoundTrip)
+    await loadRelations(runner, result.rows, ir.relations, onRoundTrip)
+    return {
+      rows: result.rows.map((row) => projectRow(row, ir.select, ir.relations)),
+      affected: 0,
+    }
+  }
+
+  if (ir.mode === 'count') {
+    const result = await executePrimitive(runner, ir, predicate, onRoundTrip)
+    return { rows: [], affected: 0, count: Number(result.rows[0]?.count ?? 0) }
+  }
+
+  const result = await executePrimitive(runner, ir, predicate, onRoundTrip)
+  return {
+    rows: ir.returning === undefined ? [] : result.rows,
+    affected: result.count,
+  }
+}
+
+/** Invokes a named Postgres routine with a single jsonb argument. Missing routines map to `Invalid`. */
+export async function executeRpc(
+  runner: SqlRunner,
+  routine: string,
+  args: Readonly<Record<string, unknown>>,
+  onRoundTrip: RoundTripCounter,
+): Promise<unknown> {
+  try {
+    onRoundTrip()
+    const result = await runner.unsafe(`SELECT ${quoteRoutine(routine)}($1::jsonb) AS result`, [
+      JSON.stringify(args),
+    ])
+    return decodeJsonResult(result.rows[0]?.result)
+  } catch (error) {
+    mapPostgresError(error, 'rpc')
+  }
+}

package/src/fixtures-sql.ts

@@ -0,0 +1,104 @@
+/**
+ * Statements that drop and recreate the database conformance fixtures.
+ *
+ * Authored as an array because Neon's HTTP endpoint rejects multi-statement query text, and the
+ * `assay_echo` body is dollar-quoted, so splitting the blob on `;` at runtime would corrupt it.
+ */
+export const ASSAY_FIXTURE_STATEMENTS: readonly string[] = [
+  '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;
+$$`,
+]
+
+/** 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;
+$$;
+`