@pgpm/metaschema-schema 0.16.0

package/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Dan Lynch <pyramation@gmail.com>
+Copyright (c) 2025 Constructive
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/Makefile

@@ -0,0 +1,6 @@
+EXTENSION = metaschema-schema
+DATA = sql/metaschema-schema--0.15.5.sql
+
+PG_CONFIG = pg_config
+PGXS := $(shell $(PG_CONFIG) --pgxs)
+include $(PGXS)

package/README.md

@@ -0,0 +1,324 @@
+# @pgpm/metaschema-schema
+
+<p align="center" width="100%">
+  <img height="250" src="https://raw.githubusercontent.com/constructive-io/constructive/refs/heads/main/assets/outline-logo.svg" />
+</p>
+
+<p align="center" width="100%">
+  <a href="https://github.com/constructive-io/pgpm-modules/actions/workflows/ci.yml">
+    <img height="20" src="https://github.com/constructive-io/pgpm-modules/actions/workflows/ci.yml/badge.svg" />
+  </a>
+   <a href="https://github.com/constructive-io/pgpm-modules/blob/main/LICENSE"><img height="20" src="https://img.shields.io/badge/license-MIT-blue.svg"/></a>
+   <a href="https://www.npmjs.com/package/@pgpm/metaschema-schema"><img height="20" src="https://img.shields.io/github/package-json/v/constructive-io/pgpm-modules?filename=packages%2Fmetaschema-schema%2Fpackage.json"/></a>
+</p>
+
+Database metadata utilities and introspection functions.
+
+## Overview
+
+`@pgpm/metaschema-schema` provides a comprehensive metadata management system for PostgreSQL databases. This package creates tables and schemas for storing and querying database structure information including databases, schemas, tables, fields, constraints, indexes, and more. It enables runtime schema introspection, metadata-driven code generation, and database structure management.
+
+## Features
+
+- **Database Metadata Storage**: Store information about databases, schemas, tables, and fields
+- **Constraint Tracking**: Track primary keys, foreign keys, unique constraints, and check constraints
+- **Index Management**: Store and query index definitions
+- **Trigger and Procedure Metadata**: Track database functions and triggers
+- **RLS and Policy Information**: Store row-level security policies
+- **Extension Tracking**: Manage database extensions and their relationships
+- **API and Site Metadata**: Store API configurations and site information
+- **GraphQL Integration**: Smart tags and annotations for GraphQL schema generation
+
+## Installation
+
+If you have `pgpm` installed:
+
+```bash
+pgpm install @pgpm/metaschema-schema
+pgpm deploy
+```
+
+This is a quick way to get started. The sections below provide more detailed installation options.
+
+### Prerequisites
+
+```bash
+# Install pgpm CLI 
+npm install -g pgpm
+
+# Start local Postgres (via Docker) and export env vars
+pgpm docker start
+eval "$(pgpm env)"
+```
+
+> **Tip:** Already running Postgres? Skip the Docker step and just export your `PG*` environment variables.
+
+### **Add to an Existing Package**
+
+```bash
+# 1. Install the package
+pgpm install @pgpm/metaschema-schema
+
+# 2. Deploy locally
+pgpm deploy 
+```
+
+### **Add to a New Project**
+
+```bash
+# 1. Create a workspace
+pgpm init workspace
+
+# 2. Create your first module
+cd my-workspace
+pgpm init
+
+# 3. Install a package
+cd packages/my-module
+pgpm install @pgpm/metaschema-schema
+
+# 4. Deploy everything
+pgpm deploy --createdb --database mydb1
+```
+
+## Core Schemas
+
+### metaschema_public Schema
+
+Stores database structure metadata:
+
+- **database**: Database definitions with schema names and hashes
+- **schema**: Schema definitions within databases
+- **table**: Table definitions with RLS, timestamps, and naming conventions
+- **field**: Column definitions with types, constraints, and validation rules
+- **primary_key_constraint**: Primary key definitions
+- **foreign_key_constraint**: Foreign key relationships
+- **unique_constraint**: Unique constraints
+- **check_constraint**: Check constraint definitions
+- **index**: Index definitions
+- **trigger**: Trigger definitions
+- **procedure**: Stored procedure definitions
+- **policy**: Row-level security policies
+- **extension**: PostgreSQL extensions
+- **database_extension**: Extension installations per database
+
+### metaschema_private Schema
+
+Private schema for internal metadata operations.
+
+### services_public Schema
+
+Application-level metadata:
+
+- **apis**: API configurations
+- **api_extensions**: API extension relationships
+- **api_modules**: API module definitions
+- **api_schemata**: API schema configurations
+- **sites**: Site definitions
+- **apps**: Application definitions
+- **domains**: Domain configurations
+- **site_metadata**: Site metadata
+- **site_modules**: Site module configurations
+- **site_themes**: Site theme definitions
+
+## Usage
+
+### Storing Database Metadata
+
+```sql
+-- Create a database entry
+INSERT INTO metaschema_public.database (name, label, schema_name, private_schema_name)
+VALUES ('my_app', 'My Application', 'my_app_public', 'my_app_private')
+RETURNING id;
+
+-- Create a schema entry
+INSERT INTO metaschema_public.schema (database_id, name)
+VALUES ('database-uuid', 'public')
+RETURNING id;
+
+-- Create a table entry
+INSERT INTO metaschema_public.table (
+  database_id,
+  schema_id,
+  name,
+  label,
+  use_rls,
+  timestamps,
+  peoplestamps
+) VALUES (
+  'database-uuid',
+  'schema-uuid',
+  'users',
+  'Users',
+  true,
+  true,
+  true
+);
+
+-- Create field entries
+INSERT INTO metaschema_public.field (
+  database_id,
+  table_id,
+  name,
+  label,
+  type,
+  is_required,
+  field_order
+) VALUES
+  ('database-uuid', 'table-uuid', 'id', 'ID', 'uuid', true, 1),
+  ('database-uuid', 'table-uuid', 'email', 'Email', 'email', true, 2),
+  ('database-uuid', 'table-uuid', 'name', 'Name', 'text', false, 3);
+```
+
+### Querying Metadata
+
+```sql
+-- Get all tables in a database
+SELECT t.name, t.label, s.name as schema_name
+FROM metaschema_public.table t
+JOIN metaschema_public.schema s ON t.schema_id = s.id
+WHERE t.database_id = 'database-uuid';
+
+-- Get all fields for a table
+SELECT f.name, f.label, f.type, f.is_required, f.default_value
+FROM metaschema_public.field f
+WHERE f.table_id = 'table-uuid'
+ORDER BY f.field_order;
+
+-- Get foreign key relationships
+SELECT 
+  fk.name as constraint_name,
+  t1.name as from_table,
+  t2.name as to_table
+FROM metaschema_public.foreign_key_constraint fk
+JOIN metaschema_public.table t1 ON fk.table_id = t1.id
+JOIN metaschema_public.table t2 ON fk.foreign_table_id = t2.id
+WHERE fk.database_id = 'database-uuid';
+```
+
+### Smart Tags for GraphQL
+
+The package supports smart tags for GraphQL schema generation:
+
+```sql
+-- Add smart tags to a table
+UPDATE metaschema_public.table
+SET smart_tags = '{
+  "@omit": "create,update,delete",
+  "@name": "CustomTableName"
+}'::jsonb
+WHERE id = 'table-uuid';
+
+-- Add smart tags to a field
+UPDATE metaschema_public.field
+SET smart_tags = '{
+  "@omit": true,
+  "@deprecated": "Use new_field instead"
+}'::jsonb
+WHERE id = 'field-uuid';
+```
+
+## Table Structures
+
+### database Table
+
+Stores database definitions:
+- `id`: UUID primary key
+- `owner_id`: Owner UUID
+- `schema_hash`: Unique schema hash
+- `schema_name`: Public schema name
+- `private_schema_name`: Private schema name
+- `name`: Database name
+- `label`: Display label
+- `hash`: Database hash
+
+### table Table
+
+Stores table definitions:
+- `id`: UUID primary key
+- `database_id`: Foreign key to database
+- `schema_id`: Foreign key to schema
+- `name`: Table name
+- `label`: Display label
+- `description`: Table description
+- `smart_tags`: JSONB smart tags for GraphQL
+- `use_rls`: Enable row-level security
+- `timestamps`: Enable created_at/updated_at
+- `peoplestamps`: Enable created_by/updated_by
+- `plural_name`: Plural form for API
+- `singular_name`: Singular form for API
+- `inherits_id`: Table inheritance
+
+### field Table
+
+Stores column definitions:
+- `id`: UUID primary key
+- `database_id`: Foreign key to database
+- `table_id`: Foreign key to table
+- `name`: Column name
+- `label`: Display label
+- `description`: Column description
+- `smart_tags`: JSONB smart tags
+- `is_required`: NOT NULL constraint
+- `default_value`: Default value
+- `is_hidden`: Hide from API
+- `type`: PostgreSQL type
+- `field_order`: Display order
+- `regexp`: Validation regex
+- `chk`: Check constraint JSON
+- `min`/`max`: Numeric constraints
+
+## Use Cases
+
+### Schema-Driven Code Generation
+
+Use metadata to generate:
+- GraphQL schemas
+- TypeScript types
+- API documentation
+- Database migration scripts
+- Admin interfaces
+
+### Runtime Schema Introspection
+
+Query metadata at runtime to:
+- Build dynamic forms
+- Generate validation rules
+- Create custom queries
+- Implement multi-tenancy
+
+### Database Documentation
+
+Generate documentation from metadata:
+- Entity-relationship diagrams
+- Data dictionaries
+- API specifications
+
+## Dependencies
+
+- `@pgpm/database-jobs`: Background job processing
+- `@pgpm/inflection`: String inflection utilities
+- `@pgpm/types`: Core PostgreSQL types
+- `@pgpm/verify`: Verification utilities
+
+## Testing
+
+```bash
+pnpm test
+```
+
+## Related Tooling
+
+* [pgpm](https://github.com/constructive-io/constructive/tree/main/packages/pgpm): **🖥️ PostgreSQL Package Manager** for modular Postgres development. Works with database workspaces, scaffolding, migrations, seeding, and installing database packages.
+* [pgsql-test](https://github.com/constructive-io/constructive/tree/main/packages/pgsql-test): **📊 Isolated testing environments** with per-test transaction rollbacks—ideal for integration tests, complex migrations, and RLS simulation.
+* [supabase-test](https://github.com/constructive-io/constructive/tree/main/packages/supabase-test): **🧪 Supabase-native test harness** preconfigured for the local Supabase stack—per-test rollbacks, JWT/role context helpers, and CI/GitHub Actions ready.
+* [graphile-test](https://github.com/constructive-io/constructive/tree/main/packages/graphile-test): **🔐 Authentication mocking** for Graphile-focused test helpers and emulating row-level security contexts.
+* [pgsql-parser](https://github.com/constructive-io/pgsql-parser): **🔄 SQL conversion engine** that interprets and converts PostgreSQL syntax.
+* [libpg-query-node](https://github.com/constructive-io/libpg-query-node): **🌉 Node.js bindings** for `libpg_query`, converting SQL into parse trees.
+* [pg-proto-parser](https://github.com/constructive-io/pg-proto-parser): **📦 Protobuf parser** for parsing PostgreSQL Protocol Buffers definitions to generate TypeScript interfaces, utility functions, and JSON mappings for enums.
+
+## Disclaimer
+
+AS DESCRIBED IN THE LICENSES, THE SOFTWARE IS PROVIDED "AS IS", AT YOUR OWN RISK, AND WITHOUT WARRANTIES OF ANY KIND.
+
+No developer or entity involved in creating this software will be liable for any claims or damages whatsoever associated with your use, inability to use, or your interaction with other users of the code, including any direct, indirect, incidental, special, exemplary, punitive or consequential damages, or loss of profits, cryptocurrencies, tokens, or anything else of value.

package/deploy/schemas/metaschema_private/schema.sql

@@ -0,0 +1,12 @@
+-- Deploy schemas/metaschema_private/schema to pg
+
+BEGIN;
+
+CREATE SCHEMA metaschema_private;
+
+GRANT USAGE ON SCHEMA metaschema_private TO authenticated;
+ALTER DEFAULT PRIVILEGES IN SCHEMA metaschema_private GRANT ALL ON TABLES TO authenticated;
+ALTER DEFAULT PRIVILEGES IN SCHEMA metaschema_private GRANT ALL ON SEQUENCES TO authenticated;
+ALTER DEFAULT PRIVILEGES IN SCHEMA metaschema_private GRANT ALL ON FUNCTIONS TO authenticated;
+
+COMMIT;

package/deploy/schemas/metaschema_public/schema.sql

@@ -0,0 +1,12 @@
+-- Deploy schemas/metaschema_public/schema to pg
+
+BEGIN;
+
+CREATE SCHEMA metaschema_public;
+
+GRANT USAGE ON SCHEMA metaschema_public TO authenticated;
+ALTER DEFAULT PRIVILEGES IN SCHEMA metaschema_public GRANT ALL ON TABLES TO authenticated;
+ALTER DEFAULT PRIVILEGES IN SCHEMA metaschema_public GRANT ALL ON SEQUENCES TO authenticated;
+ALTER DEFAULT PRIVILEGES IN SCHEMA metaschema_public GRANT ALL ON FUNCTIONS TO authenticated;
+
+COMMIT;

package/deploy/schemas/metaschema_public/tables/check_constraint/table.sql

@@ -0,0 +1,33 @@
+-- Deploy schemas/metaschema_public/tables/check_constraint/table to pg
+
+-- requires: schemas/metaschema_public/schema
+-- requires: schemas/metaschema_public/tables/database/table 
+-- requires: schemas/metaschema_public/tables/table/table 
+
+BEGIN;
+
+CREATE TABLE metaschema_public.check_constraint (
+  id uuid PRIMARY KEY DEFAULT uuid_generate_v4 (),
+  database_id uuid NOT NULL DEFAULT uuid_nil(),
+  
+  table_id uuid NOT NULL,
+  name text,
+  type text,
+  field_ids uuid[] NOT NULL,
+  expr jsonb,
+  --
+
+  CONSTRAINT db_fkey FOREIGN KEY (database_id) REFERENCES metaschema_public.database (id) ON DELETE CASCADE,
+  CONSTRAINT table_fkey FOREIGN KEY (table_id) REFERENCES metaschema_public.table (id) ON DELETE CASCADE,
+
+  UNIQUE (table_id, name),
+  CHECK (field_ids <> '{}')
+);
+
+COMMENT ON CONSTRAINT table_fkey ON metaschema_public.check_constraint IS E'@omit manyToMany';
+COMMENT ON CONSTRAINT db_fkey ON metaschema_public.check_constraint IS E'@omit manyToMany';
+
+CREATE INDEX check_constraint_table_id_idx ON metaschema_public.check_constraint ( table_id );
+CREATE INDEX check_constraint_database_id_idx ON metaschema_public.check_constraint ( database_id );
+
+COMMIT;

package/deploy/schemas/metaschema_public/tables/database/indexes/databases_database_unique_name_idx.sql

@@ -0,0 +1,20 @@
+-- Deploy schemas/metaschema_public/tables/database/indexes/databases_database_unique_name_idx to pg
+-- requires: schemas/metaschema_private/schema
+-- requires: schemas/metaschema_public/schema
+-- requires: schemas/metaschema_public/tables/database/table
+
+BEGIN;
+
+CREATE FUNCTION metaschema_private.database_name_hash (name text)
+  RETURNS bytea
+  AS $BODY$
+  SELECT
+    DECODE(MD5(LOWER(inflection.plural (name))), 'hex');
+$BODY$
+LANGUAGE sql
+IMMUTABLE;
+
+CREATE UNIQUE INDEX databases_database_unique_name_idx ON metaschema_public.database (owner_id, metaschema_private.database_name_hash (name));
+
+COMMIT;
+

package/deploy/schemas/metaschema_public/tables/database/table.sql

@@ -0,0 +1,30 @@
+-- Deploy schemas/metaschema_public/tables/database/table to pg
+
+-- requires: schemas/metaschema_public/schema
+
+BEGIN;
+
+CREATE TABLE metaschema_public.database (
+  id uuid PRIMARY KEY DEFAULT uuid_generate_v4 (),
+  owner_id uuid,
+  schema_hash text,
+  schema_name text,
+  private_schema_name text,
+  
+  name text,
+  label text,
+  
+  hash uuid,
+  unique(schema_hash),
+  unique(schema_name),
+  unique(private_schema_name)
+);
+
+ALTER TABLE metaschema_public.database
+  ADD CONSTRAINT db_namechk CHECK (char_length(name) > 2);
+
+COMMENT ON COLUMN metaschema_public.database.schema_hash IS '@omit';
+-- COMMENT ON COLUMN metaschema_public.database.schema_name IS '@omit';
+-- COMMENT ON COLUMN metaschema_public.database.private_schema_name IS '@omit';
+
+COMMIT;

package/deploy/schemas/metaschema_public/tables/database_extension/table.sql

@@ -0,0 +1,23 @@
+-- Deploy schemas/metaschema_public/tables/database_extension/table to pg
+
+-- requires: schemas/metaschema_public/schema
+-- requires: schemas/metaschema_public/tables/extension/table 
+-- requires: schemas/metaschema_public/tables/database/table 
+
+BEGIN;
+
+CREATE TABLE metaschema_public.database_extension (
+  name text NOT NULL PRIMARY KEY,
+  database_id uuid NOT NULL,
+
+  --
+
+  CONSTRAINT ext_fkey FOREIGN KEY (name) REFERENCES metaschema_public.extension (name) ON DELETE CASCADE,
+  CONSTRAINT db_fkey FOREIGN KEY (database_id) REFERENCES metaschema_public.database (id) ON DELETE CASCADE,
+  UNIQUE (database_id, name)
+);
+
+COMMENT ON CONSTRAINT db_fkey ON metaschema_public.database_extension IS E'@omit manyToMany';
+CREATE INDEX database_extension_database_id_idx ON metaschema_public.database_extension ( database_id );
+
+COMMIT;

package/deploy/schemas/metaschema_public/tables/extension/table.sql

@@ -0,0 +1,28 @@
+-- Deploy schemas/metaschema_public/tables/extension/table to pg
+
+-- requires: schemas/metaschema_public/schema
+
+BEGIN;
+
+-- TODO add package name
+
+CREATE TABLE metaschema_public.extension (
+  name text NOT NULL PRIMARY KEY,
+  public_schemas text[],
+  private_schemas text[]
+);
+
+INSERT INTO metaschema_public.extension (name, public_schemas, private_schemas) VALUES 
+  (
+    'collections',
+    ARRAY['metaschema_public'],
+    ARRAY['metaschema_private']
+  ),
+  (
+    'meta',
+    ARRAY['services_public'],
+    ARRAY['services_private']
+  )
+;
+
+COMMIT;

package/deploy/schemas/metaschema_public/tables/field/indexes/databases_field_uniq_names_idx.sql

@@ -0,0 +1,13 @@
+-- Deploy schemas/metaschema_public/tables/field/indexes/databases_field_uniq_names_idx to pg
+
+-- requires: schemas/metaschema_public/schema
+-- requires: schemas/metaschema_public/tables/field/table
+
+BEGIN;
+
+CREATE UNIQUE INDEX databases_field_uniq_names_idx ON metaschema_public.field (
+   -- strip out any _id, etc., so that if you do create one and make foreign key relation, there is no conflict
+  table_id, DECODE(MD5(LOWER(regexp_replace(name, '^(.+?)(_row_id|_id|_uuid|_fk|_pk)$', '\1', 'i'))), 'hex')
+);
+
+COMMIT;

package/deploy/schemas/metaschema_public/tables/field/table.sql

@@ -0,0 +1,85 @@
+-- Deploy schemas/metaschema_public/tables/field/table to pg
+
+
+-- requires: schemas/metaschema_public/schema
+-- requires: schemas/metaschema_public/tables/table/table
+
+BEGIN;
+
+-- TODO should we just query this table and make a view?
+-- https://www.postgresql.org/docs/9.2/catalog-pg-attribute.html
+
+-- IF YOU WANT TO REMOVE THIS TABLE, answer the qustion, how would you add RLS to this:
+--  SELECT 
+--       attrelid::text AS tbl
+--       , attname::text            AS col
+--       , p.attnum::int as id,
+--       t.typname as typename
+
+--   FROM   pg_catalog.pg_attribute p
+--   INNER JOIN  pg_catalog.pg_type t ON (t.oid = p.atttypid)
+--   WHERE  attrelid = 'dude_schema.products'::regclass
+--   AND    p.attnum > 0
+--   AND    NOT attisdropped;
+
+CREATE TYPE metaschema_public.field_category AS ENUM ('core', 'module', 'app');
+
+CREATE TABLE metaschema_public.field (
+  id uuid PRIMARY KEY DEFAULT uuid_generate_v4 (),
+  database_id uuid NOT NULL DEFAULT uuid_nil(),
+  
+  table_id uuid NOT NULL,
+  
+  name text NOT NULL,
+  label text,
+  
+  description text,
+  smart_tags jsonb,
+
+  is_required boolean NOT NULL DEFAULT FALSE,
+  default_value text NULL DEFAULT NULL,
+  -- AST column for SQL expression validation (AST is the source of truth)
+  default_value_ast jsonb NULL DEFAULT NULL,
+
+  -- hidden from API using @omit keyword, a Graphile feature ONLY
+  is_hidden boolean NOT NULL DEFAULT FALSE,
+
+  type citext NOT NULL,
+
+  -- typmods DO THIS SOON!
+
+  field_order int not null default 0,
+
+  regexp text default null,
+  chk jsonb default null,
+  chk_expr jsonb default null,
+  min float default null,
+  max float default null,
+
+  tags citext[] NOT NULL DEFAULT '{}',
+
+  -- Field categorization for system/module/app fields (mirrors table categorization)
+  -- category: 'core' for system fields (id, entity_id, actor_id), 'module' for module-generated fields, 'app' for user-defined fields
+  -- module: the module name that created this field (e.g., 'users', 'permissions', 'memberships')
+  -- scope: membership_type int (1=app, 2=org, 3=group, NULL=not scoped)
+  category metaschema_public.field_category NOT NULL DEFAULT 'app',
+  module text NULL,
+  scope int NULL,
+
+  --
+  CONSTRAINT db_fkey FOREIGN KEY (database_id) REFERENCES metaschema_public.database (id) ON DELETE CASCADE,
+  CONSTRAINT table_fkey FOREIGN KEY (table_id) REFERENCES metaschema_public.table (id) ON DELETE CASCADE,
+
+  UNIQUE (table_id, name)
+);
+
+COMMENT ON CONSTRAINT table_fkey ON metaschema_public.field IS E'@omit manyToMany';
+COMMENT ON CONSTRAINT db_fkey ON metaschema_public.field IS E'@omit manyToMany';
+
+CREATE INDEX field_table_id_idx ON metaschema_public.field ( table_id );
+CREATE INDEX field_database_id_idx ON metaschema_public.field ( database_id );
+
+-- Smart comment for Graphile SQL expression validator plugin
+COMMENT ON COLUMN metaschema_public.field.default_value IS E'@sqlExpression';
+
+COMMIT;

package/deploy/schemas/metaschema_public/tables/foreign_key_constraint/table.sql

@@ -0,0 +1,40 @@
+-- Deploy schemas/metaschema_public/tables/foreign_key_constraint/table to pg
+
+-- requires: schemas/metaschema_public/tables/field/table
+-- requires: schemas/metaschema_public/tables/table/table
+-- requires: schemas/metaschema_public/schema
+
+BEGIN;
+
+CREATE TABLE metaschema_public.foreign_key_constraint (
+    id uuid PRIMARY KEY DEFAULT uuid_generate_v4 (),
+    database_id uuid NOT NULL DEFAULT uuid_nil(),
+    
+    table_id uuid NOT NULL,
+    name text,
+    description text,
+    smart_tags jsonb,
+    type text,
+    field_ids uuid[] NOT NULL,
+    ref_table_id uuid NOT NULL REFERENCES metaschema_public.table (id) ON DELETE CASCADE,
+    ref_field_ids uuid[] NOT NULL,
+    delete_action char(1) DEFAULT 'c', -- postgres default is 'a'
+    update_action char(1) DEFAULT 'a',
+
+    -- 
+
+    CONSTRAINT db_fkey FOREIGN KEY (database_id) REFERENCES metaschema_public.database (id) ON DELETE CASCADE,
+    CONSTRAINT table_fkey FOREIGN KEY (table_id) REFERENCES metaschema_public.table (id) ON DELETE CASCADE,
+
+    UNIQUE(table_id, name),
+    CHECK (field_ids <> '{}'),
+    CHECK (ref_field_ids <> '{}')
+);
+
+COMMENT ON CONSTRAINT table_fkey ON metaschema_public.foreign_key_constraint IS E'@omit manyToMany';
+COMMENT ON CONSTRAINT db_fkey ON metaschema_public.foreign_key_constraint IS E'@omit manyToMany';
+
+CREATE INDEX foreign_key_constraint_table_id_idx ON metaschema_public.foreign_key_constraint ( table_id );
+CREATE INDEX foreign_key_constraint_database_id_idx ON metaschema_public.foreign_key_constraint ( database_id );
+
+COMMIT;