@rebasepro/types 0.11.1-canary.gfadf355 → 0.12.0

package/src/types/api_keys.ts

@@ -1,16 +1,56 @@
-/** A single permission entry scoping an API key to a collection and its allowed operations. */
+/**
+ * Service API keys — machine-to-machine authentication for scripts, cron jobs
+ * and third-party integrations.
+ *
+ * The wire contract lives here because all three sides need it and used to
+ * declare it separately: `@rebasepro/server` implements the routes,
+ * `@rebasepro/client` calls them, and {@link ApiKeysAPI} types the SDK surface.
+ * The client's copy had already drifted — it never gained `admin`.
+ *
+ * The database row itself (`ApiKey`, which carries `key_hash`) stays in the
+ * server package: nothing off the server may see it.
+ */
+
+/**
+ * A single permission entry scoping an API key to a collection and set of
+ * operations.
+ *
+ * Use `"*"` as the collection value to grant access to all collections (and all
+ * custom functions). Custom functions are addressed with the `functions`
+ * namespace: `"functions"` grants every function, `"functions/<name>"` grants a
+ * single one.
+ *
+ * @group Models
+ */
 export interface ApiKeyPermission {
+    /** Collection slug, `"functions"`/`"functions/<name>"`, or `"*"` for everything. */
     collection: string;
+    /** Allowed operations on the collection. */
     operations: ("read" | "write" | "delete")[];
 }
 
-/** An API key with the secret portion masked (returned by list / get / update). */
+/**
+ * An API key with the secret portion masked — what list / get / update return.
+ * @group Models
+ */
 export interface ApiKeyMasked {
     id: string;
     name: string;
+    /** First 12 characters of the plaintext key, for display only. */
     key_prefix: string;
     permissions: ApiKeyPermission[];
+    /**
+     * When true, the key is granted the `admin` role: it passes the admin-gated
+     * routes (users, roles, cron, backups, logs, API keys) and the RLS
+     * `default_admin` policies. Non-admin keys carry only the `service` role —
+     * RLS grants them nothing unless a collection policy names that role.
+     */
     admin: boolean;
+    /**
+     * Requests per 15-minute window. `null` means "no per-key override" — the
+     * data rate limiter then applies its default API-key limit (1000/window
+     * unless configured otherwise), not unlimited.
+     */
     rate_limit: number | null;
     created_by: string;
     created_at: string;
@@ -20,29 +60,45 @@ export interface ApiKeyMasked {
     revoked_at: string | null;
 }
 
-/** An API key including the full secret (returned only on creation). */
+/**
+ * Returned exactly once, when a key is created. The `key` field holds the full
+ * plaintext key — it is never stored or returned again.
+ * @group Models
+ */
 export interface ApiKeyWithSecret extends ApiKeyMasked {
+    /** Full plaintext API key (e.g. `rk_live_abc123...`). */
     key: string;
 }
 
-/** Payload for creating a new API key. */
+/**
+ * Payload for creating a new API key.
+ * @group Models
+ */
 export interface CreateApiKeyRequest {
     name: string;
     permissions: ApiKeyPermission[];
+    /** When true, grants the `admin` role. See {@link ApiKeyMasked.admin}. */
     admin?: boolean;
+    /** Requests per 15-minute window. Omit or `null` for the server default. */
     rate_limit?: number | null;
+    /** ISO-8601 expiration timestamp. Omit for no expiration. */
     expires_at?: string | null;
 }
 
-/** Payload for updating an existing API key. */
+/**
+ * Payload for updating an existing API key. Only the fields provided change.
+ * @group Models
+ */
 export interface UpdateApiKeyRequest {
     name?: string;
     permissions?: ApiKeyPermission[];
+    /** When true, grants the `admin` role. See {@link ApiKeyMasked.admin}. */
     admin?: boolean;
     rate_limit?: number | null;
     expires_at?: string | null;
 }
 
+/** @group Models */
 export interface ApiKeysAPI {
     listKeys(): Promise<{ keys: ApiKeyMasked[] }>;
     getKey(id: string): Promise<{ key: ApiKeyMasked }>;

package/src/types/collections.ts

@@ -5,6 +5,7 @@ import type { EnumValues, Properties, PostgresProperties, FirebaseProperties, Mo
 import type { User } from "../users";
 import type { Relation } from "./relations";
 import type { SecurityRule } from "./security_rules";
+import { getDataSourceCapabilities } from "./data_source";
 import type { WhereFilterOp, FilterValues, FilterPreset } from "./filter-operators";
 
 /**
@@ -116,30 +117,34 @@ export interface BaseCollectionConfig<M extends Record<string, unknown> = Record
      */
     auth?: boolean | AuthCollectionConfig;
 
-    /**
-     * Opt out of the framework's default Row Level Security policies.
-     *
-     * The schema generator automatically injects, for every collection, a
-     * baseline SELECT policy granting the trusted server context and the
-     * `admin` role read access (reads run under a restricted role, so RLS
-     * default-denies without it). For auth collections it additionally injects
-     * a self-read policy (`id = auth.uid()`) and an admin-only write gate
-     * (INSERT/UPDATE/DELETE require the `admin` role or the trusted server
-     * context), making privileged columns such as `roles` safe by default.
-     *
-     * Author-defined `securityRules` are permissive and broaden access on top
-     * of these defaults. Set this flag to `true` to remove the defaults
-     * entirely and take full responsibility for the collection's RLS.
-     *
-     * @default false
-     */
-    disableDefaultPolicies?: boolean;
 
 
 
 
 
 
+    /**
+     * Row-level authorization rules for this collection.
+     *
+     * Driver-agnostic on purpose, unlike `disableDefaultPolicies`, `table` and
+     * `relations`, which are declared on {@link PostgresCollectionConfig} only.
+     * The rules are a *contract* — who may read or write which rows — and each
+     * engine enforces it its own way:
+     *
+     * - **Postgres** compiles them to real `CREATE POLICY` statements and lets
+     *   the database enforce them (see {@link PostgresCollectionConfig.securityRules},
+     *   which narrows this with the raw-SQL details).
+     * - **MongoDB** translates them into a query filter it AND-s into every
+     *   read and write, honouring `access`, `ownerField`, `roles`, `mode` and
+     *   the `operation`/`operations` selectors, and making a best effort at raw
+     *   `using`/`withCheck` SQL.
+     * - **Firestore** does not implement them at all; its own rules language is
+     *   evaluated by Google, not from here. `supportsRLS` on
+     *   {@link DataSourceCapabilities} reports which engines generate policies,
+     *   which is not the same question as whether an engine honours a rule.
+     */
+    securityRules?: readonly SecurityRule[];
+
     /**
      * This interface defines all the callbacks that can be used when a entity
      * is being created, updated or deleted.
@@ -202,26 +207,6 @@ export interface BaseCollectionConfig<M extends Record<string, unknown> = Record
 
 
 
-    /**
-     * The database table name for this collection.
-     * Automatically set for PostgreSQL collections.
-     * For non-SQL backends, this may be undefined.
-     */
-    table?: string;
-
-    /**
-     * Relations defined for this collection.
-     * Populated at normalization time from inline relation properties
-     * or explicit relation definitions.
-     */
-    relations?: Relation[];
-
-    /**
-     * Security rules for this collection (Row Level Security).
-     * When defined, the backend enforces access control policies.
-     */
-    securityRules?: readonly SecurityRule[];
-
 }
 
 // ── Driver-specific collection types ──────────────────────────────────
@@ -279,6 +264,25 @@ export interface PostgresCollectionConfig<M extends Record<string, unknown> = Re
      * - `auth.jwt()`   — full JWT claims as JSONB
      */
     securityRules?: readonly SecurityRule[];
+
+    /**
+     * Opt out of the framework's default Row Level Security policies.
+     *
+     * The schema generator automatically injects, for every collection, a
+     * baseline SELECT policy granting the trusted server context and the
+     * `admin` role read access (reads run under a restricted role, so RLS
+     * default-denies without it). For auth collections it additionally injects
+     * a self-read policy (`id = auth.uid()`) and an admin-only write gate
+     * (INSERT/UPDATE/DELETE require the `admin` role or the trusted server
+     * context), making privileged columns such as `roles` safe by default.
+     *
+     * Author-defined `securityRules` are permissive and broaden access on top
+     * of these defaults. Set this flag to `true` to remove the defaults
+     * entirely and take full responsibility for the collection's RLS.
+     *
+     * @default false
+     */
+    disableDefaultPolicies?: boolean;
 }
 
 /**
@@ -424,6 +428,32 @@ export function isPostgresCollectionConfig<C extends CollectionConfig<any, any>>
     return !collection.engine || collection.engine === "postgres";
 }
 
+/**
+ * Narrows to the SQL collection fields — `table`, `relations`,
+ * `disableDefaultPolicies` — by asking the engine's declared capabilities
+ * rather than by naming Postgres.
+ *
+ * The two halves of this already existed and were never joined. The engine
+ * split (`PostgresCollectionConfig` / `FirebaseCollectionConfig` /
+ * `MongoDBCollectionConfig`) said which fields belong to which engine at the
+ * type level; {@link DataSourceCapabilities} said the same thing at runtime,
+ * down to a `supportsRelations` flag. So call sites guarded on the capability
+ * and then read a field the base type had to declare for them — which is why
+ * those fields were on the base, and why a MongoDB collection could be written
+ * with a `table`.
+ *
+ * Prefer this over {@link isPostgresCollectionConfig} wherever the question is
+ * "does this collection live in a SQL table", so a custom SQL engine
+ * registered through `registerDataSourceCapabilities` is included.
+ *
+ * @group Models
+ */
+export function isRelationalCollectionConfig<C extends CollectionConfig<any, any>>(
+    collection: C
+): collection is C & PostgresCollectionConfig<any, any> {
+    return getDataSourceCapabilities(collection.engine).supportsRelations;
+}
+
 /**
  * Type guard for Firebase / Firestore collections.
  * @group Models

package/src/types/data_source.ts

@@ -37,6 +37,17 @@ export interface DataSourceCapabilities {
     /** Does this source support real-time listeners? */
     supportsRealtime: boolean;
 
+    /**
+     * Does this source store vectors natively?
+     *
+     * `VectorProperty` carries a `dimensions` and is pgvector-shaped. It was
+     * the one driver-specific property kind with no flag to gate it, so unlike
+     * every other field in this descriptor there was not even a runtime answer
+     * to appeal to — a Firestore collection could declare an embedding column
+     * and no driver would do anything with it.
+     */
+    supportsVectors: boolean;
+
     /**
      * Canonical filter operators this engine can execute.
      *
@@ -197,6 +208,7 @@ export const POSTGRES_CAPABILITIES: DataSourceCapabilities = {
     supportsReferences: false,
     supportsColumnTypes: true,
     supportsRealtime: true,
+    supportsVectors: true,
     filterOperators: ALL_WHERE_FILTER_OPS,
     // `via` is absent: its join path is authored source → target with no
     // stated inverse, so the driver has nothing to reverse into a filter.
@@ -216,6 +228,7 @@ export const FIREBASE_CAPABILITIES: DataSourceCapabilities = {
     supportsReferences: true,
     supportsColumnTypes: false,
     supportsRealtime: true,
+    supportsVectors: false,
     // Firestore has no SQL pattern matching — the driver throws on the LIKE
     // family, so the UI must never offer it.
     filterOperators: ALL_WHERE_FILTER_OPS.filter(op =>
@@ -237,6 +250,7 @@ export const MONGODB_CAPABILITIES: DataSourceCapabilities = {
     supportsReferences: true,
     supportsColumnTypes: false,
     supportsRealtime: false,
+    supportsVectors: false,
     filterOperators: ALL_WHERE_FILTER_OPS,
     filterableRelationKinds: [],
     supportsSQLAdmin: false,
@@ -258,6 +272,7 @@ export const DEFAULT_CAPABILITIES: DataSourceCapabilities = {
     supportsReferences: true,
     supportsColumnTypes: true,
     supportsRealtime: true,
+    supportsVectors: true,
     filterOperators: ALL_WHERE_FILTER_OPS,
     // The exception to this descriptor's "enable everything" rule. The other
     // flags hide a tab or a picker when they are wrong; this one decides

package/src/types/history.ts

@@ -0,0 +1,66 @@
+/**
+ * Entity change history — the shape a history entry has on the wire.
+ *
+ * This was declared three times: once in `@rebasepro/server-postgres`, once in
+ * `@rebasepro/server-mongo`, and once again in the admin's `useHistory` hook.
+ * The two driver copies disagreed on the one field that matters for a consumer,
+ * `updated_at`, which was a `string` in Postgres and a `Date` in MongoDB — so
+ * nothing could read history without first choosing a driver.
+ *
+ * The contract is the wire shape, and on the wire it is an ISO-8601 string.
+ * A driver whose stored document differs (MongoDB keeps a `Date` and an
+ * `ObjectId`) declares that storage row for itself and maps to this on the way
+ * out; it is not the shared type.
+ *
+ * @group Backend
+ */
+
+/**
+ * One recorded change to a row.
+ * @group Backend
+ */
+export interface EntityHistoryEntry {
+    id: string;
+    /** The table (Postgres) or collection (MongoDB) the row belongs to. */
+    table_name: string;
+    /** The row's id, as a string regardless of its native type. */
+    entity_id: string;
+    action: "create" | "update" | "delete";
+    /** Which fields changed. `null` for creates and deletes. */
+    changed_fields: string[] | null;
+    values: Record<string, unknown> | null;
+    previous_values: Record<string, unknown> | null;
+    updated_by: string | null;
+    /** ISO-8601. A driver storing a native date converts on read. */
+    updated_at: string;
+}
+
+/**
+ * Arguments to record one change.
+ * @group Backend
+ */
+export interface RecordHistoryParams {
+    tableName: string;
+    id: string;
+    action: "create" | "update" | "delete";
+    values?: Record<string, unknown> | null;
+    previousValues?: Record<string, unknown> | null;
+    updatedBy?: string | null;
+}
+
+/**
+ * How much history to keep. Pruning runs per row after each write.
+ * @group Backend
+ */
+export interface HistoryRetentionConfig {
+    /** Max entries per row. Oldest pruned first. Default 200. */
+    maxEntries: number;
+    /** Entries older than this many days are pruned. Default 90. */
+    ttlDays: number;
+}
+
+/** @group Backend */
+export interface FetchHistoryOptions {
+    limit?: number;
+    offset?: number;
+}

package/src/types/index.ts

@@ -21,6 +21,8 @@ export * from "./component_ref";
 export * from "./auth_adapter";
 export * from "./database_adapter";
 export * from "./api_keys";
+export * from "./history";
+export * from "./postgres_introspection";
 export * from "./project_manifest";
 export * from "./collection_contract";
 export * from "./schema_version";

package/src/types/postgres_introspection.ts

@@ -0,0 +1,101 @@
+/**
+ * Shapes returned by Postgres introspection queries.
+ *
+ * These are **not** driver-agnostic and they are not a model of anything — each
+ * one is the projection of a specific `SELECT` against `information_schema` or
+ * `pg_policies`, which is why the fields are snake_cased and why `is_nullable`
+ * is a string rather than a boolean. They describe rows, not concepts.
+ *
+ * They were spread across three places that had nothing to do with each other:
+ * the `Table*` shapes sat in `websockets.ts`, next to the WebSocket frame types
+ * they share no relationship with, and `PostgresPolicy` was declared twice — in
+ * `@rebasepro/admin`'s RLS tab and again in `@rebasepro/studio`'s RLS editor,
+ * the second with a comment explaining it was inline "to avoid depending on
+ * @rebasepro/studio". Neither had to: this package is already a dependency of
+ * both.
+ *
+ * Producer: `@rebasepro/server-postgres`. Consumers: the collection editor, the
+ * studio schema browser, the RLS editors.
+ */
+
+/**
+ * A column, as `information_schema.columns` reports it.
+ * @group Models
+ */
+export interface TableColumnInfo {
+    column_name: string;
+    data_type: string;
+    udt_name: string;
+    /** `"YES"` or `"NO"` — `information_schema` reports this as text. */
+    is_nullable: string;
+    column_default: string | null;
+    character_maximum_length: number | null;
+    /** Enum values, populated for USER-DEFINED (enum) columns */
+    enum_values?: string[];
+}
+
+/** @group Models */
+export interface TableForeignKeyInfo {
+    column_name: string;
+    foreign_table_name: string;
+    foreign_column_name: string;
+}
+
+/** @group Models */
+export interface TableJunctionInfo {
+    junction_table_name: string;
+    source_column_name: string;
+    target_table_name: string;
+    target_column_name: string;
+}
+
+/**
+ * A policy as the *table metadata* query projects it.
+ *
+ * Distinct from {@link PostgresPolicy}, which is the RLS editor's fuller
+ * projection of `pg_policies` — this one carries only what the collection
+ * editor needs to show that a table is protected.
+ *
+ * @group Models
+ */
+export interface TablePolicyInfo {
+    policy_name: string;
+    roles: string[];
+    cmd: string;
+    qual?: string;
+    with_check?: string;
+}
+
+/** @group Models */
+export interface TableMetadata {
+    columns: TableColumnInfo[];
+    foreignKeys: TableForeignKeyInfo[];
+    junctions: TableJunctionInfo[];
+    policies: TablePolicyInfo[];
+}
+
+/**
+ * A row of `pg_policies`, as the RLS editors read it.
+ *
+ * Note the unseparated column names (`policyname`, `tablename`) — those are
+ * Postgres's, not ours. See {@link TablePolicyInfo} for the narrower projection
+ * the collection editor uses.
+ *
+ * @group Models
+ */
+export interface PostgresPolicy {
+    policyname: string;
+    tablename: string;
+    permissive: "PERMISSIVE" | "RESTRICTIVE";
+    roles: string[];
+    cmd: "SELECT" | "INSERT" | "UPDATE" | "DELETE" | "ALL";
+    /** The `USING` clause. */
+    qual: string | null;
+    /** The `WITH CHECK` clause. */
+    with_check: string | null;
+    /**
+     * Whether this policy exists in the live database, in the collection's
+     * `securityRules`, or both. Computed by the editor, not by Postgres.
+     */
+    status?: "live" | "code_only" | "both";
+}

package/src/types/properties.ts

@@ -2,7 +2,6 @@ import type { ComponentRef } from "./component_ref";
 
 import type { Entity, EntityReference, EntityRelation, EntityValues, GeoPoint, Vector } from "./entities";
 import type { JoinStep, OnAction, Relation, ResolvedRelation } from "./relations";
-import type { CollectionConfig, FilterValues, WhereFilterOp } from "./collections";
 import type { ColorKey, ColorScheme } from "./chips";
 import type { AuthState } from "../controllers/auth_state";
 import type { AfterReadProps, BeforeSaveProps } from "./entity_callbacks";
@@ -65,19 +64,49 @@ export type Properties = {
     [key: string]: Property;
 };
 
+/**
+ * `Omit` that survives a union.
+ *
+ * `Property` is a union discriminated on `type`, and a bare `Omit<Property, K>`
+ * collapses it into one object whose `type` is the union of every tag — so
+ * `property.type === "string"` stops narrowing and the concrete property types
+ * become unreachable. The `T extends unknown` clause makes it distribute, so
+ * each member is omitted from separately and keeps its own discriminant.
+ */
+type DistributiveOmit<T, K extends PropertyKey> = T extends unknown ? Omit<T, K> : never;
+
+/**
+ * The fields that describe a property's **column**, which only an engine with
+ * columns has.
+ *
+ * `columnType` names a Postgres type (`uuid`, `bigserial`, `jsonb`, `text[]`)
+ * and `columnName` overrides the snake_case derivation used to build a column
+ * name. `DataSourceCapabilities.supportsColumnTypes` already reported this at
+ * runtime — `false` for both document engines — while the types let a MongoDB
+ * property declare `columnType: "bigserial"`.
+ *
+ * They stay declared on the concrete property interfaces rather than moving,
+ * because that is where their per-type value unions live; what changes is that
+ * the document engines' property aliases omit them.
+ */
+type SqlColumnFields = "columnType" | "columnName";
+
 export type PostgresProperty = Exclude<Property, ReferenceProperty>;
 export type PostgresProperties = {
     [key: string]: PostgresProperty;
 };
 
-export type FirebaseProperty = Exclude<Property, RelationProperty>;
+export type FirebaseProperty = DistributiveOmit<Exclude<Property, RelationProperty | VectorProperty>, SqlColumnFields>;
 export type FirebaseProperties = {
     [key: string]: FirebaseProperty;
 };
 
 // MongoDB is a document store: it uses references (stored pointers), not
 // SQL-style relations/joins. Same gating as Firestore.
-export type MongoProperty = Exclude<Property, RelationProperty>;
+//
+// `vector` goes with them: it is pgvector-shaped, only `@rebasepro/server-postgres`
+// reads it, and `supportsVectors` on the engine's capabilities says so.
+export type MongoProperty = DistributiveOmit<Exclude<Property, RelationProperty | VectorProperty>, SqlColumnFields>;
 export type MongoProperties = {
     [key: string]: MongoProperty;
 };
@@ -473,20 +502,6 @@ export interface ReferenceProperty extends BaseProperty {
      * property.
      */
     path?: string;
-    /**
-     * Allow selection of entities that pass the given filter only.
-     * e.g. `fixedFilter: { age: [">=", 18] }`
-     */
-    fixedFilter?: FilterValues<string>;
-
-    /**
-     * Should the reference include the ID of the entity. Defaults to `true`
-     */
-    includeId?: boolean;
-    /**
-     * Should the reference include a link to the entity (open the entity details). Defaults to `true`
-     */
-    includeEntityLink?: boolean;
 }
 
 /**
@@ -548,29 +563,6 @@ export interface RelationProperty extends BaseProperty {
      * collection's `relations` array.
      */
     resolvedRelation?: ResolvedRelation;
-
-    // ─── UI configuration ───
-
-    /**
-     * Allow selection of entities that pass the given filter only.
-     * e.g. `fixedFilter: { age: [">=", 18] }`
-     */
-    fixedFilter?: FilterValues<string>;
-
-    /**
-     * Should the reference include the ID of the entity. Defaults to `true`
-     */
-    includeId?: boolean;
-    /**
-     * Should the reference include a link to the entity (open the entity details). Defaults to `true`
-     */
-    includeEntityLink?: boolean;
-
-    /**
-     * Choose the widget to use for selecting the relation.
-     * Defaults to `select`.
-     */
-    widget?: "select" | "dialog";
 }
 
 export interface ArrayProperty extends BaseProperty {
@@ -634,17 +626,6 @@ export interface ArrayProperty extends BaseProperty {
      * Rules for validating this property
      */
     validation?: ArrayPropertyValidationSchema;
-
-    /**
-     * Can the elements in this array be reordered. Defaults to `true`.
-     * This prop has no effect if `disabled` is set to true.
-     */
-    sortable?: boolean;
-    /**
-     * Can the elements in this array be added. Defaults to `true`
-     * This prop has no effect if `disabled` is set to true.
-     */
-    canAddElements?: boolean;
 }
 
 export interface MapProperty extends BaseProperty {
@@ -665,6 +646,12 @@ export interface MapProperty extends BaseProperty {
      * Order in which the properties are displayed.
      * If you are specifying your collection as code, the order is the same as the
      * one you define in `properties`, and you don't need to specify this prop.
+     *
+     * Stays on the property rather than moving to the `admin` block, unlike the
+     * rest of the map's presentation options: `sortProperties` in
+     * `@rebasepro/common` reads it recursively, and `@rebasepro/firebase` calls
+     * that when it builds collections. A core package cannot read the admin
+     * block — the field exists only once `@rebasepro/admin-types` is installed.
      */
     propertiesOrder?: string[];
     /**
@@ -673,13 +660,13 @@ export interface MapProperty extends BaseProperty {
      * will be considered valid, even if you set `required` in the properties.
      */
     validation?: PropertyValidationSchema;
-    /**
-     * Properties that are displayed when rendered as a preview
-     */
-    previewProperties?: string[];
     /**
      * Render this map as a key-value table that allows to use
      * arbitrary keys. You don't need to define the properties in this case.
+     *
+     * Core rather than admin despite the wording: it says the map has no
+     * declared shape, which is what the OpenAPI generator emits the schema
+     * from (`additionalProperties` instead of a property list).
      */
     keyValue?: boolean;
 }

package/src/types/websockets.ts

@@ -115,45 +115,3 @@ export interface ChannelHistoryMessage extends WebSocketMessage {
      */
     latestSeq?: number;
 }
-
-/**
- * Column metadata returned by table introspection.
- */
-export interface TableColumnInfo {
-    column_name: string;
-    data_type: string;
-    udt_name: string;
-    is_nullable: string;
-    column_default: string | null;
-    character_maximum_length: number | null;
-    /** Enum values, populated for USER-DEFINED (enum) columns */
-    enum_values?: string[];
-}
-
-export interface TableForeignKeyInfo {
-    column_name: string;
-    foreign_table_name: string;
-    foreign_column_name: string;
-}
-
-export interface TableJunctionInfo {
-    junction_table_name: string;
-    source_column_name: string;
-    target_table_name: string;
-    target_column_name: string;
-}
-
-export interface TablePolicyInfo {
-    policy_name: string;
-    roles: string[];
-    cmd: string;
-    qual?: string;
-    with_check?: string;
-}
-
-export interface TableMetadata {
-    columns: TableColumnInfo[];
-    foreignKeys: TableForeignKeyInfo[];
-    junctions: TableJunctionInfo[];
-    policies: TablePolicyInfo[];
-}