@akal/pg-conformance 0.0.0-stage → 0.0.15

package/index.d.ts

@@ -0,0 +1,147 @@
+/** A DDL case that builds objects from an empty schema. */
+export interface ObjectCase {
+  id: string
+  sql: string
+  minPgVersion?: number
+}
+
+/** A case exercising a renderer against DDL that is awkward to reproduce. */
+export interface HardCase {
+  id: string
+  sql: string
+  minPgVersion?: number
+}
+
+/**
+ * A case for a dependency-ordering algorithm.
+ *
+ * `statements` are given in an order that does not apply. `requires` lists
+ * `[before, after]` pairs, matched as substrings, that any correct order must
+ * satisfy — a precedence rather than one expected permutation, so tie-breaking
+ * can change without invalidating the case.
+ */
+export interface OrderingCase {
+  id: string
+  description: string
+  statements: string[]
+  requires: Array<[string, string]>
+}
+
+/**
+ * A schema change any migration tool must make in both directions: from
+ * `before` to `after` and back, leaving each identical to a database built
+ * directly from it. `preserve` queries must return the same rows before and
+ * after migrating — the data a correct migration keeps.
+ */
+export interface MigrationCase {
+  id: string
+  category:
+    | 'enum' | 'identity' | 'serial' | 'storage' | 'generated' | 'dependants'
+    | 'creation_order' | 'removal_order' | 'foreign_key'
+    | 'schemas' | 'routines' | 'partitions' | 'rls' | 'triggers' | 'types' | 'sequences' | 'constraints'
+  description: string
+  before: string
+  after: string
+  preserve?: string[]
+  minPgVersion?: number
+}
+
+/**
+ * One schema written two ways: as a developer writes it and as PostgreSQL
+ * renders it. A tool comparing schemas must call the pair identical.
+ */
+export interface EquivalenceCase {
+  id: string
+  kind: 'check' | 'index' | 'policy' | 'view' | 'domain' | 'generated'
+  description: string
+  written: string
+  rendered: string
+}
+
+/**
+ * Rows a data migration must carry over, both ways. `schema` builds the same
+ * structure on both sides; `before` holds the target's rows and `after` the
+ * source's. Migrating either into the other must leave every `compare` query
+ * returning what it returns on a database built from the other directly.
+ */
+export interface DataCase {
+  id: string
+  description: string
+  schema: string
+  before: string
+  after: string
+  compare: string[]
+  minPgVersion?: number
+}
+
+export interface CorpusByName {
+  objects: ObjectCase[]
+  'hard-cases': HardCase[]
+  ordering: OrderingCase[]
+  migrations: MigrationCase[]
+  equivalences: EquivalenceCase[]
+  data: DataCase[]
+}
+
+/** One relation and everything attached to it. */
+export interface StateTable {
+  schema: string
+  name: string
+  kind: 'table' | 'partitioned_table' | 'foreign_table'
+  unlogged: boolean
+  partition_of: string | null
+  partition_bound: string | null
+  partition_by: string | null
+  inherits: string[] | null
+  options: string[] | null
+  rls_enabled: boolean
+  rls_forced: boolean
+  comment: string | null
+  columns: StateColumn[] | null
+  constraints: Array<{ name: string; type: string; definition: string; validated: boolean; deferrable: boolean; deferred: boolean }> | null
+  indexes: Array<{ name: string; definition: string }> | null
+  policies: Array<{ name: string; command: string; permissive: boolean; roles: string[] | null; using: string | null; with_check: string | null }> | null
+  triggers: Array<{ name: string; definition: string }> | null
+}
+
+export interface StateColumn {
+  name: string
+  position: number
+  type: string
+  not_null: boolean
+  default: string | null
+  identity: 'always' | 'by_default' | null
+  identity_options: { start: number; increment: number; min: number; max: number; cache: number; cycle: boolean } | null
+  generated: 'stored' | null
+  storage: 'plain' | 'external' | 'main' | 'extended' | null
+  storage_is_default: boolean
+  compression: 'lz4' | 'pglz' | null
+  /** Null when inherited rather than set explicitly. */
+  collation: string | null
+  comment: string | null
+}
+
+/**
+ * A schema as data, rather than as an answer to "are these the same?".
+ *
+ * Sourced from pg_catalog, so it can express what information_schema cannot:
+ * partition bounds, identity sequence options, storage, compression and
+ * whether a collation was chosen or inherited.
+ */
+export interface SchemaState {
+  meta: { server_version_num: number; schemas: string[] }
+  tables: StateTable[]
+  views: Array<{ schema: string; name: string; materialized: boolean; definition: string; options: string[] | null; comment: string | null; columns: Array<{ name: string; type: string }> | null }>
+  sequences: Array<{ schema: string; name: string; type: string; start: number; increment: number; min: number; max: number; cache: number; cycle: boolean; owned_by: string | null }>
+  routines: Array<{ schema: string; name: string; kind: 'function' | 'procedure'; arguments: string; definition: string; comment: string | null }>
+  types: Array<{ schema: string; name: string; kind: 'enum' | 'domain' | 'composite'; labels: string[] | null; base_type: string | null; not_null: boolean; default: string | null; constraints: string[] | null; attributes: Array<{ name: string; type: string }> | null }>
+  extensions: Array<{ name: string; version: string }>
+}
+
+export declare const stateSqlPath: string
+export declare function stateSql(schemas?: string[]): string
+
+export declare const fingerprintSqlPath: string
+export declare function fingerprintSql(schemas?: string[]): string
+export declare const corpora: Array<keyof CorpusByName>
+export declare function loadCorpus<K extends keyof CorpusByName>(name: K): CorpusByName[K]

package/index.js

@@ -0,0 +1,87 @@
+/**
+ * @akal/pg-conformance
+ *
+ * Data only: a schema fingerprint query and a corpus of DDL cases. There is no
+ * runner here on purpose — property-based and example-based harnesses
+ * legitimately differ, and each consumer already has one. What must not differ
+ * is the definition of "are these two schemas the same", which is why that
+ * lives in exactly one place.
+ */
+import { readFileSync } from 'node:fs'
+import { fileURLToPath } from 'node:url'
+import { dirname, join } from 'node:path'
+
+const HERE = dirname(fileURLToPath(import.meta.url))
+
+/** Absolute path to the fingerprint query, for consumers that shell out to psql. */
+export const fingerprintSqlPath = join(HERE, 'fingerprint.sql')
+
+/**
+ * The fingerprint query, with the schema list substituted in.
+ *
+ * Schema names are quoted here rather than by the caller: the query embeds them
+ * as SQL literals, so this is the one place an injection could be introduced.
+ * A name containing a single quote is rejected rather than escaped, because no
+ * legitimate schema in this context has one and silently accepting it would
+ * hide a caller bug.
+ */
+export function fingerprintSql(schemas = ['public']) {
+  return readFileSync(fingerprintSqlPath, 'utf8').replaceAll('__SCHEMAS__', schemaList(schemas))
+}
+
+/**
+ * Quote a schema list for embedding as SQL literals.
+ *
+ * Any name PostgreSQL accepts is accepted here — `App Data`, `Ünïcode` — and
+ * quoted by doubling its single quotes, which makes it a literal that cannot
+ * end early. Restricting names to plain identifiers instead made a schema
+ * named with a space impossible to compare at all.
+ *
+ * A backslash is still rejected: with standard_conforming_strings off it would
+ * be an escape inside the literal, and no sane schema name needs one. So is
+ * NUL, which no PostgreSQL name can contain. This is the single place either
+ * query could take an injection.
+ */
+function schemaList(schemas) {
+  if (!Array.isArray(schemas) || schemas.length === 0) {
+    throw new TypeError('expected a non-empty array of schema names')
+  }
+  for (const s of schemas) {
+    if (typeof s !== 'string' || s.length === 0 || /[\\\0]/.test(s)) {
+      throw new TypeError(`unsupported schema name ${JSON.stringify(s)}`)
+    }
+  }
+  return schemas.map(s => `'${s.replaceAll("'", "''")}'`).join(',')
+}
+
+/** Absolute path to the state query, for consumers that shell out to psql. */
+export const stateSqlPath = join(HERE, 'state.sql')
+
+/**
+ * The schema-state query, with the schema list substituted in.
+ *
+ * Where the fingerprint answers "are these the same?", this answers "what is
+ * there?" — the same catalog knowledge shaped as a JSON document, so a
+ * consumer can compute its own diff rather than trusting someone else's idea
+ * of what changed. Schema names are validated and quoted here for the same
+ * reason as in fingerprintSql.
+ */
+export function stateSql(schemas = ['public']) {
+  return readFileSync(stateSqlPath, 'utf8').replaceAll('__SCHEMAS__', schemaList(schemas))
+}
+
+/** Corpus names that ship with this package. */
+export const corpora = ['objects', 'hard-cases', 'ordering', 'migrations', 'equivalences', 'data']
+
+/**
+ * Load one corpus by name.
+ *
+ * Cases are plain data — SQL plus metadata — so a harness in any language can
+ * consume them without agreeing on how they should be run.
+ */
+export function loadCorpus(name) {
+  if (!corpora.includes(name)) {
+    throw new Error(`loadCorpus: unknown corpus ${JSON.stringify(name)}; expected one of ${corpora.join(', ')}`)
+  }
+  return JSON.parse(readFileSync(join(HERE, 'corpus', `${name}.json`), 'utf8'))
+}

package/package.json

@@ -1,6 +1,48 @@
 {
   "name": "@akal/pg-conformance",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.0.15",
+  "description": "A PostgreSQL schema fingerprint and DDL conformance corpus, shared by tools that need to agree on whether two schemas are the same.",
+  "type": "module",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "exports": {
+    ".": "./index.js",
+    "./fingerprint.sql": "./fingerprint.sql",
+    "./corpus/*.json": "./corpus/*.json"
+  },
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "fingerprint.sql",
+    "state.sql",
+    "corpus",
+    "src"
+  ],
+  "scripts": {
+    "test": "node --test test/*.test.js"
+  },
+  "keywords": [
+    "postgresql",
+    "postgres",
+    "schema",
+    "migration",
+    "diff",
+    "conformance",
+    "fingerprint"
+  ],
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/akalsoftware/pg-conformance.git"
+  },
+  "homepage": "https://github.com/akalsoftware/pg-conformance#readme",
+  "bugs": {
+    "url": "https://github.com/akalsoftware/pg-conformance/issues"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

package/src/Conformance.php

@@ -0,0 +1,97 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Akal\PgConformance;
+
+/**
+ * Accessor for the shared conformance data.
+ *
+ * The PHP and JavaScript accessors deliberately expose the same three things —
+ * the fingerprint query, its path, and the corpora — so that a harness written
+ * in either language is asking the same question of the database.
+ */
+final class Conformance
+{
+    /** Path to the fingerprint query, for callers that shell out to psql. */
+    public static function fingerprintSqlPath(): string
+    {
+        return dirname(__DIR__) . '/fingerprint.sql';
+    }
+
+    /**
+     * The fingerprint query with the schema list substituted in.
+     *
+     * Schema names are quoted here rather than by the caller, because the query
+     * embeds them as SQL literals. A name that is not a plain identifier is
+     * rejected rather than escaped: none is legitimate here, and accepting one
+     * quietly would hide a bug in the caller.
+     *
+     * @param list<string> $schemas
+     */
+    public static function fingerprintSql(array $schemas = ['public']): string
+    {
+        return str_replace('__SCHEMAS__', self::schemaList($schemas), (string) file_get_contents(self::fingerprintSqlPath()));
+    }
+
+    /**
+     * Quote a schema list for embedding as SQL literals.
+     *
+     * Rejects anything that is not a plain identifier rather than escaping it:
+     * none is legitimate here, and accepting one quietly would hide a caller
+     * bug. The single place either query could take an injection.
+     *
+     * @param list<string> $schemas
+     */
+    private static function schemaList(array $schemas): string
+    {
+        if ($schemas === []) {
+            throw new \InvalidArgumentException('expected at least one schema name');
+        }
+
+        foreach ($schemas as $schema) {
+            if (preg_match('/^[A-Za-z_][A-Za-z0-9_$]*$/', $schema) !== 1) {
+                throw new \InvalidArgumentException(sprintf('unsupported schema name "%s"', $schema));
+            }
+        }
+
+        return implode(',', array_map(static fn (string $s): string => "'$s'", $schemas));
+    }
+
+    /** Path to the state query, for callers that shell out to psql. */
+    public static function stateSqlPath(): string
+    {
+        return dirname(__DIR__) . '/state.sql';
+    }
+
+    /**
+     * The schema-state query with the schema list substituted in.
+     *
+     * @param list<string> $schemas
+     */
+    public static function stateSql(array $schemas = ['public']): string
+    {
+        return str_replace('__SCHEMAS__', self::schemaList($schemas), (string) file_get_contents(self::stateSqlPath()));
+    }
+
+    /** Corpus names that ship with this package. */
+    public const CORPORA = ['objects', 'hard-cases', 'ordering', 'migrations', 'equivalences'];
+
+    /**
+     * Load one corpus by name.
+     *
+     * @return array<int, array<string, mixed>>
+     */
+    public static function loadCorpus(string $name): array
+    {
+        if (!in_array($name, self::CORPORA, true)) {
+            throw new \InvalidArgumentException(
+                sprintf('loadCorpus: unknown corpus "%s"; expected one of %s', $name, implode(', ', self::CORPORA))
+            );
+        }
+
+        $path = dirname(__DIR__) . "/corpus/$name.json";
+
+        return json_decode((string) file_get_contents($path), true, 512, JSON_THROW_ON_ERROR);
+    }
+}

package/state.sql

@@ -0,0 +1,234 @@
+-- Structural state of a PostgreSQL schema, as one JSON document.
+--
+-- The fingerprint answers "are these the same?". This answers "what is there?"
+-- — the same catalog knowledge, shaped for a consumer to read rather than for
+-- a string comparison. A tool holding two of these can compute its own diff
+-- without trusting anyone else's idea of what changed.
+--
+-- Losslessness is the whole point, and it is why this reads pg_catalog rather
+-- than information_schema or an existing schema API. Neither can express a
+-- partition bound, an identity column's sequence options, per-column storage,
+-- compression, or whether a collation was set or inherited. Every one of those
+-- has hidden a real bug, so a state document blind to them would be a step
+-- backwards from the fingerprint it sits beside.
+--
+-- Two conventions, both learned from getting them wrong:
+--
+--   Values are semantic, not catalog shorthand. attstorage 'x' is reported as
+--   "extended" and attcompression 'l' as "lz4", because a consumer should not
+--   have to memorise single letters that mean nothing outside pg_catalog.
+--
+--   Inherited defaults are null, not spelled out. A column that merely uses
+--   the database collation reports null rather than "default", or every text
+--   column in an unchanged schema would read as different.
+--
+-- Arrays are ordered so two runs over identical schemas produce byte-identical
+-- output; jsonb sorts object keys itself.
+--
+-- Usage: replace __SCHEMAS__ with a quoted, comma-separated schema list. The
+-- language accessors do this and handle quoting.
+--
+-- Requires PostgreSQL 14 or newer.
+
+SELECT jsonb_pretty(jsonb_build_object(
+
+  'meta', jsonb_build_object(
+    'server_version_num', current_setting('server_version_num')::int,
+    'schemas', (SELECT jsonb_agg(s ORDER BY s) FROM unnest(ARRAY[__SCHEMAS__]) AS s)
+  ),
+
+  -- Tables, partitioned tables and foreign tables, with their columns inline:
+  -- a column has no meaning apart from its relation, and nesting keeps a
+  -- consumer from having to re-join them.
+  'tables', COALESCE((
+    SELECT jsonb_agg(t ORDER BY t->>'schema', t->>'name') FROM (
+      SELECT jsonb_build_object(
+        'schema', n.nspname,
+        'name', c.relname,
+        'kind', CASE c.relkind WHEN 'r' THEN 'table' WHEN 'p' THEN 'partitioned_table'
+                               WHEN 'f' THEN 'foreign_table' END,
+        'unlogged', c.relpersistence = 'u',
+        'partition_of', (SELECT p.relname FROM pg_inherits i
+                          JOIN pg_class p ON p.oid = i.inhparent
+                         WHERE i.inhrelid = c.oid AND c.relispartition),
+        'partition_bound', pg_get_expr(c.relpartbound, c.oid),
+        'partition_by', CASE WHEN c.relkind = 'p' THEN pg_get_partkeydef(c.oid) END,
+        'inherits', (SELECT jsonb_agg(p.relname ORDER BY p.relname)
+                       FROM pg_inherits i JOIN pg_class p ON p.oid = i.inhparent
+                      WHERE i.inhrelid = c.oid AND NOT c.relispartition),
+        'options', (SELECT jsonb_agg(o ORDER BY o) FROM unnest(c.reloptions) AS o),
+        'rls_enabled', c.relrowsecurity,
+        'rls_forced', c.relforcerowsecurity,
+        'comment', obj_description(c.oid, 'pg_class'),
+        'columns', (
+          SELECT jsonb_agg(jsonb_build_object(
+            'name', a.attname,
+            'position', a.attnum,
+            'type', format_type(a.atttypid, a.atttypmod),
+            'not_null', a.attnotnull,
+            'default', pg_get_expr(d.adbin, d.adrelid),
+            'identity', CASE a.attidentity WHEN 'a' THEN 'always'
+                                           WHEN 'd' THEN 'by_default' END,
+            'identity_options', (
+              SELECT jsonb_build_object('start', s.seqstart, 'increment', s.seqincrement,
+                                        'min', s.seqmin, 'max', s.seqmax,
+                                        'cache', s.seqcache, 'cycle', s.seqcycle)
+                FROM pg_sequence s
+               WHERE a.attidentity <> ''
+                 AND s.seqrelid = pg_get_serial_sequence(
+                       format('%I.%I', n.nspname, c.relname), a.attname)::regclass),
+            'generated', CASE a.attgenerated WHEN 's' THEN 'stored' END,
+            'storage', CASE a.attstorage WHEN 'p' THEN 'plain' WHEN 'e' THEN 'external'
+                                         WHEN 'm' THEN 'main'  WHEN 'x' THEN 'extended' END,
+            -- Null unless it differs from the type's own default, so a storage
+            -- setting nobody chose does not read as a deliberate one.
+            'storage_is_default', a.attstorage = tp.typstorage,
+            'compression', CASE a.attcompression WHEN 'l' THEN 'lz4'
+                                                 WHEN 'p' THEN 'pglz' END,
+            -- An inherited collation is not a property of the column.
+            'collation', NULLIF(co.collname, 'default'),
+            'comment', col_description(c.oid, a.attnum)
+          ) ORDER BY a.attnum)
+          FROM pg_attribute a
+          JOIN pg_type tp ON tp.oid = a.atttypid
+          LEFT JOIN pg_attrdef d ON d.adrelid = a.attrelid AND d.adnum = a.attnum
+          LEFT JOIN pg_collation co ON co.oid = a.attcollation
+         WHERE a.attrelid = c.oid AND a.attnum > 0 AND NOT a.attisdropped),
+        'constraints', (
+          SELECT jsonb_agg(jsonb_build_object(
+            'name', con.conname,
+            'type', CASE con.contype WHEN 'p' THEN 'primary_key' WHEN 'f' THEN 'foreign_key'
+                                     WHEN 'u' THEN 'unique' WHEN 'c' THEN 'check'
+                                     WHEN 'x' THEN 'exclusion' WHEN 'n' THEN 'not_null' END,
+            'definition', pg_get_constraintdef(con.oid),
+            'validated', con.convalidated,
+            'deferrable', con.condeferrable,
+            'deferred', con.condeferred
+          ) ORDER BY con.conname)
+          FROM pg_constraint con WHERE con.conrelid = c.oid),
+        'indexes', (
+          SELECT jsonb_agg(jsonb_build_object(
+            'name', i.indexname, 'definition', i.indexdef
+          ) ORDER BY i.indexname)
+          FROM pg_indexes i
+         WHERE i.schemaname = n.nspname AND i.tablename = c.relname),
+        'policies', (
+          SELECT jsonb_agg(jsonb_build_object(
+            'name', p.polname,
+            'command', CASE p.polcmd WHEN 'r' THEN 'select' WHEN 'a' THEN 'insert'
+                                     WHEN 'w' THEN 'update' WHEN 'd' THEN 'delete'
+                                     WHEN '*' THEN 'all' END,
+            'permissive', p.polpermissive,
+            'roles', (SELECT jsonb_agg(r.rolname ORDER BY r.rolname)
+                        FROM unnest(p.polroles) AS ro JOIN pg_roles r ON r.oid = ro),
+            'using', pg_get_expr(p.polqual, p.polrelid),
+            'with_check', pg_get_expr(p.polwithcheck, p.polrelid)
+          ) ORDER BY p.polname)
+          FROM pg_policy p WHERE p.polrelid = c.oid),
+        'triggers', (
+          SELECT jsonb_agg(jsonb_build_object(
+            'name', tg.tgname, 'definition', pg_get_triggerdef(tg.oid)
+          ) ORDER BY tg.tgname)
+          FROM pg_trigger tg
+         WHERE tg.tgrelid = c.oid AND NOT tg.tgisinternal AND tg.tgparentid = 0)
+      ) AS t
+      FROM pg_class c JOIN pg_namespace n ON n.oid = c.relnamespace
+     WHERE n.nspname IN (__SCHEMAS__) AND c.relkind IN ('r','p','f')
+    ) q), '[]'::jsonb),
+
+  'views', COALESCE((
+    SELECT jsonb_agg(v ORDER BY v->>'schema', v->>'name') FROM (
+      SELECT jsonb_build_object(
+        'schema', n.nspname, 'name', c.relname,
+        'materialized', c.relkind = 'm',
+        'definition', pg_get_viewdef(c.oid, true),
+        'options', (SELECT jsonb_agg(o ORDER BY o) FROM unnest(c.reloptions) AS o),
+        'comment', obj_description(c.oid, 'pg_class'),
+        'columns', (SELECT jsonb_agg(jsonb_build_object(
+                      'name', a.attname, 'type', format_type(a.atttypid, a.atttypmod))
+                      ORDER BY a.attnum)
+                      FROM pg_attribute a
+                     WHERE a.attrelid = c.oid AND a.attnum > 0 AND NOT a.attisdropped)
+      ) AS v
+      FROM pg_class c JOIN pg_namespace n ON n.oid = c.relnamespace
+     WHERE n.nspname IN (__SCHEMAS__) AND c.relkind IN ('v','m')
+    ) q), '[]'::jsonb),
+
+  -- Every sequence, with owned_by naming the column that brought it into being
+  -- so a consumer can tell one it must reproduce from one a column already
+  -- creates. An identity column's options are also reported on that column.
+  --
+  -- Both kinds of ownership count, and PostgreSQL records them differently: a
+  -- serial column's sequence depends on it with deptype 'a', an identity
+  -- column's with 'i'. Reading only 'a' reported every identity sequence as
+  -- standalone.
+  'sequences', COALESCE((
+    SELECT jsonb_agg(s ORDER BY s->>'schema', s->>'name') FROM (
+      SELECT jsonb_build_object(
+        'schema', n.nspname, 'name', c.relname,
+        'type', format_type(sq.seqtypid, NULL),
+        'start', sq.seqstart, 'increment', sq.seqincrement,
+        'min', sq.seqmin, 'max', sq.seqmax, 'cache', sq.seqcache, 'cycle', sq.seqcycle,
+        'owned_by', (SELECT format('%I.%I', dc.relname, da.attname)
+                       FROM pg_depend dep
+                       JOIN pg_class dc ON dc.oid = dep.refobjid
+                       JOIN pg_attribute da ON da.attrelid = dep.refobjid
+                                           AND da.attnum = dep.refobjsubid
+                      WHERE dep.objid = c.oid
+                        AND dep.classid = 'pg_class'::regclass
+                        AND dep.refclassid = 'pg_class'::regclass
+                        AND dep.refobjsubid > 0
+                        AND dep.deptype IN ('a', 'i') LIMIT 1)
+      ) AS s
+      FROM pg_sequence sq
+      JOIN pg_class c ON c.oid = sq.seqrelid
+      JOIN pg_namespace n ON n.oid = c.relnamespace
+     WHERE n.nspname IN (__SCHEMAS__)
+    ) q), '[]'::jsonb),
+
+  'routines', COALESCE((
+    SELECT jsonb_agg(f ORDER BY f->>'schema', f->>'name', f->>'arguments') FROM (
+      SELECT jsonb_build_object(
+        'schema', n.nspname, 'name', p.proname,
+        'kind', CASE p.prokind WHEN 'p' THEN 'procedure' ELSE 'function' END,
+        'arguments', pg_get_function_identity_arguments(p.oid),
+        'definition', pg_get_functiondef(p.oid),
+        'comment', obj_description(p.oid, 'pg_proc')
+      ) AS f
+      FROM pg_proc p JOIN pg_namespace n ON n.oid = p.pronamespace
+     WHERE n.nspname IN (__SCHEMAS__) AND p.prokind IN ('f','p')
+    ) q), '[]'::jsonb),
+
+  'types', COALESCE((
+    SELECT jsonb_agg(t ORDER BY t->>'schema', t->>'name') FROM (
+      SELECT jsonb_build_object(
+        'schema', n.nspname, 'name', t.typname,
+        'kind', CASE t.typtype WHEN 'e' THEN 'enum' WHEN 'd' THEN 'domain'
+                               WHEN 'c' THEN 'composite' END,
+        'labels', (SELECT jsonb_agg(e.enumlabel ORDER BY e.enumsortorder)
+                     FROM pg_enum e WHERE e.enumtypid = t.oid),
+        'base_type', CASE WHEN t.typtype = 'd'
+                          THEN format_type(t.typbasetype, t.typtypmod) END,
+        'not_null', t.typnotnull,
+        'default', pg_get_expr(t.typdefaultbin, 0),
+        'constraints', (SELECT jsonb_agg(pg_get_constraintdef(con.oid) ORDER BY con.conname)
+                          FROM pg_constraint con WHERE con.contypid = t.oid),
+        'attributes', (SELECT jsonb_agg(jsonb_build_object(
+                         'name', a.attname, 'type', format_type(a.atttypid, a.atttypmod))
+                         ORDER BY a.attnum)
+                         FROM pg_attribute a
+                        WHERE a.attrelid = t.typrelid AND a.attnum > 0 AND NOT a.attisdropped)
+      ) AS t
+      FROM pg_type t JOIN pg_namespace n ON n.oid = t.typnamespace
+     WHERE n.nspname IN (__SCHEMAS__) AND t.typtype IN ('e','d','c')
+       AND NOT EXISTS (SELECT 1 FROM pg_class c
+                        WHERE c.oid = t.typrelid AND c.relkind <> 'c')
+    ) q), '[]'::jsonb),
+
+  'extensions', COALESCE((
+    SELECT jsonb_agg(jsonb_build_object('name', e.extname, 'version', e.extversion)
+                     ORDER BY e.extname)
+      FROM pg_extension e JOIN pg_namespace n ON n.oid = e.extnamespace
+     WHERE n.nspname IN (__SCHEMAS__)), '[]'::jsonb)
+
+)) AS state;