@fabrika/db 0.8.2 → 0.9.0-cloudflare.1

package/types/src/testing-shared.d.ts

@@ -0,0 +1,193 @@
+import type { Database } from './database';
+import type { Primitive } from './description';
+import { type Tables } from './policy';
+import type { TableProbe } from './store';
+/** A value a test row holds in a column; `null` for a nullable column the fixture left empty. */
+export type SampleValue = Primitive | null;
+/** One seeded row and where it lies. */
+export interface WorldRow {
+    /** The row's key: the dimension value of a dimension table's row, a child's own key. */
+    readonly key: string;
+    /** A child row's parent key; `null` for a dimension table. */
+    readonly parent: string | null;
+    /** The value of the grant dimension the row lies in (`IsolationWorlds.dimension`). */
+    readonly scope: string;
+    /**
+     * Every dimension value the row lies in: a dimension table's own first, then each container, innermost first. A
+     * share link's chain is this list.
+     */
+    readonly chain: readonly {
+        readonly type: string;
+        readonly value: string;
+    }[];
+    /** The row's values of the policy's update columns, as seeded. */
+    readonly updates: Readonly<Record<string, SampleValue>>;
+    /**
+     * The distinct value written into every text column the fixture filled itself, in this row and in its containers.
+     * Each occurs in no other fixture, so one found in an answer to another scope is a leaked row.
+     */
+    readonly markers: readonly string[];
+}
+/** One seeded row of an application table, which lies in no dimension. */
+export interface ApplicationRow {
+    readonly key: string;
+    /** The row's values of the policy's update columns, as seeded. */
+    readonly updates: Readonly<Record<string, SampleValue>>;
+    /** The distinct value written into every text column the fixture filled itself. */
+    readonly markers: readonly string[];
+}
+/** Rows of application tables seeded together for one case, and their removal once the case is over. */
+export interface SeededApplicationRows {
+    /** Each table's row key, by table. */
+    readonly keys: Readonly<Record<string, string>>;
+    /**
+     * Deletes the rows, the rows their required foreign keys and file columns made the fixture insert, and every row
+     * that refers to one of them, however deep (what the case's handler wrote about them), in one transaction, so rows
+     * that refer to each other go together. A row already gone is skipped.
+     */
+    remove(): Promise<void>;
+}
+/** A row seeded under another: its key, and the distinct value written into every text column the fixture filled. */
+export interface SeededRow {
+    readonly key: string;
+    readonly markers: readonly string[];
+}
+/**
+ * What the isolation fixture cannot seed for a schema: a CHECK its values fail, a required foreign key to a scoped table
+ * outside the containment chain. It is a limit of the generator, named with the constraint or the column, never a
+ * failure of the handler or the policy a case is about.
+ */
+export declare class SeedLimitError extends Error {
+    readonly name = "SeedLimitError";
+}
+/** One row of a table in each of two containment chains that share no value. */
+export interface IsolationWorlds {
+    /**
+     * The dimension a caller's grants are scoped by: a dimension table's container, or its own dimension when it has
+     * none; a child table's parent's.
+     */
+    readonly dimension: string;
+    readonly own: WorldRow;
+    readonly other: WorldRow;
+}
+/** What a test kit seeds through, over its migrated schema. */
+export interface TestSeeding {
+    /**
+     * Seeds one row of `table` in each of two fresh chains, with every container row a table owns. `values` (column →
+     * value) are written into both rows of `table`: the state an endpoint's precondition needs. A text column keeps its
+     * marker, so a seed of one, or of a column that places the row, throws.
+     */
+    seedWorlds<DB, P>(tables: Tables<DB, P>, table: string, values?: Readonly<Record<string, SampleValue>>): Promise<IsolationWorlds>;
+    /**
+     * Seeds one row of the application table `table`: its key, version and creator stamped, `values` (column → value)
+     * as given, a text column too, every other column sampled. A value for a stamped column or a file column throws.
+     */
+    seedRow<DB, P>(tables: Tables<DB, P>, table: string, values?: Readonly<Record<string, SampleValue>>): Promise<ApplicationRow>;
+    /**
+     * Seeds one row of each application table `rows` names (table → column → value), as `seedRow` does, in foreign-key
+     * order: a foreign key from one of them to another holds that row's key unless the values give it. Every table's
+     * values are checked before the first insert, and a table that fails removes the rows seeded before it. `remove`
+     * deletes them, the rows a required foreign key of theirs made it insert, and every row that refers to any of them,
+     * so the next case starts without them.
+     */
+    seedApplicationRows<DB, P>(tables: Tables<DB, P>, rows: Readonly<Record<string, Readonly<Record<string, SampleValue>>>>): Promise<SeededApplicationRows>;
+    /**
+     * Seeds one row of `table`, a child or dimension table that lies in the object of `under` (a row `seedWorlds`
+     * seeded), placed in that row's chain: the row a fixture names by id, such as a note's comment. Answers its key and
+     * the markers it holds.
+     */
+    seedUnder<DB, P>(tables: Tables<DB, P>, table: string, under: WorldRow): Promise<SeededRow>;
+    /** Values for the policy's insert columns of `table` that its schema accepts: every required one, sampled; a file column a seeded file. */
+    sampleInsert<DB, P>(tables: Tables<DB, P>, table: string): Promise<Readonly<Record<string, SampleValue>>>;
+    /**
+     * The object key of every file the fixture seeded into a file column, oldest first. Each stands for an empty object,
+     * which a test's object store holds when a handler serves or opens the file.
+     */
+    seededObjects(): readonly string[];
+}
+export interface TestDatabase extends TestSeeding {
+    /** The connection `boot` binds the data layer to: on Postgres the runtime role on the migrated schema; on SQLite the database itself. */
+    readonly database: Database;
+    /** The migrated schema: `app_test_<hex>` on Postgres, `main` on SQLite. */
+    readonly schema: string;
+    /** Closes the connections and drops the schema and its roles (on SQLite: closes the in-memory database). */
+    close(): Promise<void>;
+}
+/** A column of the migrated schema, as the seeding reads it. */
+export interface SeedColumn {
+    readonly table: string;
+    readonly name: string;
+    /** The type as the database names it, for a message. */
+    readonly type: string;
+    readonly nullable: boolean;
+    /** The database fills it when an insert leaves it out: a default, an identity, a generated column. */
+    readonly defaulted: boolean;
+    /** A text type that is no enum: where nothing else fills it, the fixture writes a marker into it. */
+    readonly text: boolean;
+    /** A uuid type: a key or containment column of it holds a random uuid as its scope value. */
+    readonly uuid: boolean;
+    /** A sample of the column's type for a required column the test does not care about; a `SeedLimitError` for a type it cannot fill. */
+    readonly sample: () => Primitive;
+}
+/** A CHECK constraint of the schema, by the columns it names. */
+export interface CheckConstraint {
+    readonly name: string;
+    readonly table: string;
+    readonly columns: readonly string[];
+    /** The values of a one-column `IN (…)` list the fixture writes in its place, first one first; empty for any other CHECK. */
+    readonly values: readonly string[];
+}
+/** A live, empty file of `kind`, as the framework's put leaves one once a reference claims it. */
+export interface SeededFile {
+    readonly id: string;
+    readonly kind: string;
+    readonly objectKey: string;
+    readonly sha256: string;
+    readonly objectVersion: string;
+}
+/** A row the fixture inserted, found again by `match` (column → value): what a removal deletes. */
+export interface InsertedRow {
+    readonly table: string;
+    readonly match: ReadonlyMap<string, SampleValue>;
+}
+/** How many rows one removal deletes, referring rows included, before it gives up. */
+export declare const MAX_REMOVED_ROWS = 10000;
+/** The seed limit of a removal that reaches more than `MAX_REMOVED_ROWS` rows. */
+export declare function removalLimit(): SeedLimitError;
+/** What a kit gives the seeding: its schema's columns and CHECK constraints, and the statements it runs. */
+export interface SeedingBackend {
+    readonly columns: readonly SeedColumn[];
+    /** Every CHECK constraint of the schema's tables; read once, on the first column that needs them. */
+    checks(): Promise<readonly CheckConstraint[]>;
+    /** Inserts one row and answers it as stored; a CHECK or foreign key it fails is a `SeedLimitError` (`checkLimit`, `foreignKeyLimit`). */
+    insert(table: string, values: ReadonlyMap<string, SampleValue>): Promise<Readonly<Record<string, unknown>>>;
+    /** One row of `table`, of `columns`, or `undefined` when it has none. */
+    firstRow(table: string, columns: readonly string[]): Promise<Readonly<Record<string, unknown>> | undefined>;
+    insertFile(file: SeededFile): Promise<void>;
+    /**
+     * Deletes `rows` (each found by its `match`; one already gone is skipped) and every row that refers to one of them,
+     * however deep, in one transaction whose foreign keys are checked once all are gone, so rows that refer to each other
+     * go together. No write moves or adds a referring row between finding the rows and deleting them.
+     */
+    remove(rows: readonly InsertedRow[]): Promise<void>;
+}
+/** The seed limit of a CHECK a seeded row fails. */
+export declare function checkLimit(constraint: string, table: string): SeedLimitError;
+/** The seed limit of a foreign key a seeded row breaks. */
+export declare function foreignKeyLimit(constraint: string, table: string): SeedLimitError;
+/** The seed limit of a required column whose type the fixture has no sample of. */
+export declare function typeLimit(table: string, column: string, type: string): SeedLimitError;
+export declare function randomHex(): string;
+/**
+ * The object version a seeded file was scanned at: whoever stocks its empty object (`seededObjects`) stores it under
+ * this version, so a file of a scanning kind is served as a live one is, by its scanned version.
+ */
+export declare const SEEDED_OBJECT_VERSION = "\"seeded\"";
+/** The isolation fixtures over the schema `backend` describes. */
+export declare function testSeeding(backend: SeedingBackend): TestSeeding;
+/**
+ * The untyped handle over one table of the data layer `scoped(tables)` created; it reaches the database once `boot`
+ * has bound that layer. Every runtime check of a store applies: kind, dimension, action and the request's authority.
+ * `module` is the kit's, which refuses a production process.
+ */
+export declare function probeTable(module: string, layer: unknown, table: string): TableProbe;

package/types/src/testing-sqlite.d.ts

@@ -0,0 +1,22 @@
+import type { TableProbe } from './store';
+import { type TestDatabase } from './testing-shared';
+export { ChildTable, defineChildStore, defineStore, DimensionTable, type TableProbe } from './store';
+export { type ApplicationRow, type IsolationWorlds, type SampleValue, SEEDED_OBJECT_VERSION, type SeededApplicationRows, type SeededRow, SeedLimitError, type TestDatabase, type WorldRow, } from './testing-shared';
+export interface TestDatabaseOptions {
+    /** The application's `db/migrations/` directory. */
+    readonly migrations: string | URL;
+    /** The test file. `@fabrika/db/testing` names it when it skips; this kit never skips. */
+    readonly label: string;
+}
+/**
+ * A fresh in-memory database with the framework's and the application's migrations applied by the runner a Durable
+ * Object boots with (`@fabrika/db/sqlite-migrate`), opened with its engine (`@fabrika/db/sqlite`). Never `null`: it
+ * needs no backend, so it never skips; its type is still assignable to `@fabrika/db/testing`'s, so a generated test
+ * that checks for `null` compiles against both kits.
+ */
+export declare function testDatabase(options: TestDatabaseOptions): Promise<TestDatabase>;
+/**
+ * The untyped handle over one table of the data layer `scoped(tables)` created; it reaches the database once `boot`
+ * has bound that layer. Every runtime check of a store applies: kind, dimension, action and the request's authority.
+ */
+export declare function tableProbe(layer: unknown, table: string): TableProbe;

package/types/src/testing.d.ts

@@ -0,0 +1,35 @@
+import type { TableProbe } from './store';
+import { type TestDatabase } from './testing-shared';
+export { ChildTable, defineChildStore, defineStore, DimensionTable, type TableProbe } from './store';
+export { type ApplicationRow, type IsolationWorlds, type SampleValue, SEEDED_OBJECT_VERSION, type SeededApplicationRows, type SeededRow, SeedLimitError, type TestDatabase, type WorldRow, } from './testing-shared';
+export declare const TEST_POSTGRES_URL = "FABRIKA_TEST_POSTGRES_URL";
+/** Set to `1` by the platform build: a missing test database is then a failure, not a skip. */
+export declare const TEST_POSTGRES_REQUIRED = "FABRIKA_TEST_POSTGRES_REQUIRED";
+export interface TestDatabaseOptions {
+    /** The application's `db/migrations/` directory. */
+    readonly migrations: string | URL;
+    /** The test file, for the skip message. */
+    readonly label: string;
+    /**
+     * How long to wait for free connection slots, in ms, before the file fails saying so; `DEFAULT_CONNECTION_WAIT_MS` by
+     * default. Once one file of a process gave up, every later one fails at once.
+     */
+    readonly connectionWaitMs?: number;
+}
+/**
+ * A fresh schema with the framework's and the application's migrations applied by the real runner (`@fabrika/platform-node`) as its
+ * migration role, connected and seeded as its runtime role, or `null` after the standard skip message when
+ * `FABRIKA_TEST_POSTGRES_URL` is unset. That URL is the provisioning credential, which must be able to create roles.
+ * With `FABRIKA_TEST_POSTGRES_REQUIRED=1` a missing URL throws instead. The URL is a credential: no message names it.
+ */
+export declare function testDatabase(options: TestDatabaseOptions): Promise<TestDatabase | null>;
+/**
+ * The connections a test database holds once open: the provisioning connection, the seeder and the runtime role's.
+ * Migrating and reading the catalog each borrow one more for a moment, and so does the drop once the others ended.
+ */
+export declare const TEST_DATABASE_CONNECTIONS: number;
+/**
+ * The untyped handle over one table of the data layer `scoped(tables)` created; it reaches the database once `boot`
+ * has bound that layer. Every runtime check of a store applies: kind, dimension, action and the request's authority.
+ */
+export declare function tableProbe(layer: unknown, table: string): TableProbe;

package/types/src/vocabulary-tables.d.ts

@@ -0,0 +1,225 @@
+import type { ColumnList, ColumnPolicies, FilePolicies, RecordActions, ReferencePolicy, TableActions, Tables, VersionColumn } from './policy';
+declare const databaseType: unique symbol;
+/**
+ * The generated column list (`src/db/schema.generated.ts`), which also carries the schema's row types, so that
+ * `defineTables(vocabulary, columns)` takes no type argument. The brand is type-only: no value has the property.
+ */
+export type TypedColumnList<DB> = ColumnList<DB> & {
+    readonly [databaseType]?: DB;
+};
+/** The row types a typed column list carries; `never` for a list without them. */
+export type ColumnTypes<C> = typeof databaseType extends keyof C ? C extends {
+    readonly [databaseType]?: infer DB;
+} ? Exclude<DB, undefined> : never : never;
+/**
+ * What `defineTables(vocabulary, columns)` reads of `@fabrika/app/contract`'s `defineVocabulary` result: the action
+ * and dimension names, and each dimension's container. `@fabrika/db` does not import `@fabrika/app`.
+ */
+export interface TableVocabulary {
+    readonly actions: {
+        readonly [action: string]: string;
+    };
+    readonly dimensions: {
+        readonly [dimension: string]: {
+            readonly in?: string;
+        };
+    };
+}
+export type VocabularyAction<V> = V extends {
+    readonly actions: infer A;
+} ? keyof A & string : never;
+export type VocabularyDimension<V> = V extends {
+    readonly dimensions: infer D;
+} ? keyof D & string : never;
+/** The dimension `D` lies in, by the vocabulary; `never` for a top-level one. */
+export type VocabularyContainerOf<V, D> = V extends {
+    readonly dimensions: infer Ds;
+} ? D extends keyof Ds ? Ds[D] extends {
+    readonly in: infer C extends string;
+} ? C : never : never : never;
+/** A table without an `id` column names its key. */
+interface NamesItsKey<Col extends string> {
+    readonly key: Col;
+}
+/** `key` defaults to `id`, so it is required only where the table has no `id` column. */
+type KeyField<Col extends string> = 'id' extends Col ? {
+    readonly key?: Col;
+} : NamesItsKey<Col>;
+/** A contained dimension table's container column; `dimension`, when stated, must be the vocabulary's. */
+export interface VocabularyContainer<C extends string, Col extends string> {
+    readonly column: Col;
+    readonly dimension?: C;
+}
+/** A contained table off the `<container>_id` convention names its container column. */
+interface NamesItsContainerColumn<C extends string, Col extends string> {
+    readonly in: VocabularyContainer<C, Col>;
+}
+/** The container column defaults to `<container>_id`, so `in` is required only off that convention. */
+type ContainerField<C extends string, Col extends string> = [C] extends [never] ? {
+    readonly in?: never;
+} : `${C}_id` extends Col ? {
+    readonly in?: VocabularyContainer<C, Col>;
+} : NamesItsContainerColumn<C, Col>;
+/** The scope of a table that owns dimension `D`, which the vocabulary puts in `C` (`never`: in no container). */
+type DimensionTableScope<D extends string, C extends string, Col extends string> = {
+    readonly dimension: D;
+} & KeyField<Col> & ContainerField<C, Col>;
+/** A dimension table's scope: the dimension it owns; its container is the vocabulary's. */
+export type VocabularyDimensionScope<V, D extends string, Col extends string> = DimensionTableScope<D, VocabularyContainerOf<V, D>, Col>;
+/** A child table's scope: `column` defaults to `<parent dimension>_id`, and the inherited chain is the parent's. */
+export type VocabularyChildScope<Table extends string, Col extends string> = {
+    readonly child: Table;
+    readonly column?: Col;
+    readonly inherit?: readonly Col[];
+} & KeyField<Col>;
+interface WritableFields<Col extends string, A extends string, Ver extends Col, Acts = TableActions<A>> {
+    readonly actions: Acts;
+    readonly insert?: readonly Col[];
+    readonly update?: readonly Col[];
+    readonly version?: Ver;
+    readonly createdBy?: Col;
+    readonly columns?: ColumnPolicies<Col, A>;
+    /** The file columns, each with the file kind it holds (`c.files`): a `uuid` foreign key to `fabrika_files`. */
+    readonly files?: FilePolicies<Col>;
+}
+/**
+ * The scope of the dimension the policy states (`S`, its scope as written); for any other name, the dimension alone,
+ * so that a misspelt one is reported against the vocabulary's dimension names rather than against one of them. With
+ * no scope as written (an annotated map), every dimension's scope.
+ */
+type DimensionScopes<V, Col extends string, S> = unknown extends S ? {
+    [D in VocabularyDimension<V>]: VocabularyDimensionScope<V, D, Col>;
+}[VocabularyDimension<V>] : S extends {
+    readonly dimension: infer D extends VocabularyDimension<V>;
+} ? DimensionTableScope<D, VocabularyContainerOf<V, D>, Col> : {
+    readonly dimension: VocabularyDimension<V>;
+};
+type StatedDimensionOf<P, T> = T extends keyof P ? P[T] extends {
+    readonly scope: {
+        readonly dimension: infer D extends string;
+    };
+} ? D : never : never;
+/** A child off the `<parent dimension>_id` convention names its column for the parent. */
+interface NamesItsParentColumn<Col extends string> {
+    readonly column: Col;
+}
+/** The column for the parent defaults to `<ParentDimension>_id`, so `column` is required only off that convention. */
+type ParentColumnField<ParentDimension extends string, Col extends string> = `${ParentDimension}_id` extends Col ? {
+    readonly column?: Col;
+} : NamesItsParentColumn<Col>;
+/** The scope of a child of `Parent`, a table that owns `ParentDimension`. */
+type ChildTableScope<Parent extends string, ParentDimension extends string, Col extends string> = {
+    readonly child: Parent;
+    readonly inherit?: readonly Col[];
+} & KeyField<Col> & ParentColumnField<ParentDimension, Col>;
+/**
+ * The scope of the child as written, by the parent it states (`P`, the policies as written): its parent is a table
+ * that states a dimension scope, and its column defaults to that table's dimension. With no policies as written, any
+ * table.
+ */
+type ChildScopes<Table extends string, Col extends string, S, P> = unknown extends P ? VocabularyChildScope<Table, Col> : S extends {
+    readonly child: infer Parent extends string;
+} ? [StatedDimensionOf<P, Parent>] extends [never] ? {
+    readonly child: {
+        [T in keyof P]: P[T] extends {
+            readonly scope: {
+                readonly dimension: string;
+            };
+        } ? T : never;
+    }[keyof P] & string;
+} : ChildTableScope<Parent, StatedDimensionOf<P, Parent>, Col> : VocabularyChildScope<Table, Col>;
+type AuthoredDimensionPolicy<Col extends string, A extends string, V, Ver extends Col, S> = WritableFields<Col, A, Ver, RecordActions<A>> & {
+    readonly scope: DimensionScopes<V, Col, S>;
+};
+type AuthoredChildPolicy<Table extends string, Col extends string, A extends string, Ver extends Col, S, P> = WritableFields<Col, A, Ver, RecordActions<A>> & {
+    readonly scope: ChildScopes<Table, Col, S, P>;
+};
+/** An application table's scope: why its rows belong to no dimension; `key` defaults to `id`. */
+type AuthoredApplicationPolicy<Col extends string, A extends string, Ver extends Col> = WritableFields<Col, A, Ver> & {
+    readonly scope: {
+        readonly app: string;
+    } & KeyField<Col>;
+};
+/**
+ * One table's policy as an application writes it under a vocabulary. `S` is its scope as written: its mode picks the
+ * one policy form a mistake is reported against, rather than a union of all four. `P` is every policy as written.
+ */
+export type VocabularyTablePolicy<Table extends string, Col extends string, A extends string, V, Ver extends Col, S = unknown, P = unknown> = S extends {
+    readonly dimension: unknown;
+} ? AuthoredDimensionPolicy<Col, A, V, Ver, S> : S extends {
+    readonly child: unknown;
+} ? AuthoredChildPolicy<Table, Col, A, Ver, S, P> : S extends {
+    readonly app: unknown;
+} ? AuthoredApplicationPolicy<Col, A, Ver> : S extends {
+    readonly reference: unknown;
+} ? ReferencePolicy<Col, A> : AuthoredDimensionPolicy<Col, A, V, Ver, S> | AuthoredChildPolicy<Table, Col, A, Ver, S, P> | AuthoredApplicationPolicy<Col, A, Ver> | ReferencePolicy<Col, A>;
+type StatedScope<P, T> = T extends keyof P ? P[T] extends {
+    readonly scope: infer S;
+} ? S : unknown : unknown;
+/** The policy of table `T` with nothing stated: every form, every dimension's scope, any parent. */
+type AnyTablePolicy<DB, V, T extends keyof DB & string> = VocabularyTablePolicy<keyof DB & string, keyof DB[T] & string, VocabularyAction<V>, V, VersionColumn<DB[T]>>;
+/**
+ * Every table of the schema, and no other, maps to a policy; a misspelt action or dimension fails at its own line.
+ * `P` is the policies as written, which picks each table's form by the scope it states; a policy written under this
+ * map's own annotation states nothing narrower, so it is checked against every form.
+ */
+export type VocabularyPolicyMap<DB, V, P = unknown> = {
+    readonly [T in keyof DB & string]: AnyTablePolicy<DB, V, T> extends (T extends keyof P ? P[T] : unknown) ? AnyTablePolicy<DB, V, T> : VocabularyTablePolicy<keyof DB & string, keyof DB[T] & string, VocabularyAction<V>, V, VersionColumn<DB[T]>, StatedScope<P, T>, P>;
+};
+type Flat<T> = {
+    [K in keyof T]: T[K];
+};
+type KeyOf<S> = S extends {
+    readonly key: infer K extends string;
+} ? K : 'id';
+type ContainerColumn<S, C extends string> = S extends {
+    readonly in: {
+        readonly column: infer Col extends string;
+    };
+} ? Col : `${C}_id`;
+type ParentDimension<P, T> = T extends keyof P ? P[T] extends {
+    readonly scope: {
+        readonly dimension: infer D extends string;
+    };
+} ? D : never : never;
+type NormalScope<S, V, P> = S extends {
+    readonly dimension: infer D extends string;
+} ? Flat<{
+    readonly dimension: D;
+    readonly key: KeyOf<S>;
+} & ([VocabularyContainerOf<V, D>] extends [never] ? unknown : {
+    readonly in: {
+        readonly dimension: VocabularyContainerOf<V, D>;
+        readonly column: ContainerColumn<S, VocabularyContainerOf<V, D>>;
+    };
+})> : S extends {
+    readonly child: infer T extends string;
+} ? {
+    readonly child: T;
+    readonly key: KeyOf<S>;
+    readonly column: S extends {
+        readonly column: infer C extends string;
+    } ? C : `${ParentDimension<P, T>}_id`;
+    readonly inherit: readonly string[];
+} : S extends {
+    readonly app: infer R extends string;
+} ? {
+    readonly app: R;
+    readonly key: KeyOf<S>;
+} : S;
+/**
+ * The policies as the layer models them: every dimension table's key and container, and every child's key and
+ * column, stated as the vocabulary and the conventions derive them.
+ */
+export type NormalizedPolicies<P, V> = {
+    readonly [T in keyof P]: P[T] extends {
+        readonly scope: infer S;
+    } ? Flat<Omit<P[T], 'scope'> & {
+        readonly scope: NormalScope<S, V, P>;
+    }> : P[T];
+};
+/** Takes the policies of exactly the tables of the schema, written in the vocabulary form. */
+export type DefineVocabularyPolicies<DB, V> = <const P extends VocabularyPolicyMap<DB, V, P>>(policies: P & {
+    readonly [K in Exclude<keyof P, keyof DB>]: never;
+}) => Tables<DB, NormalizedPolicies<P, V>>;
+export {};