okmodel 0.1.1 → 0.2.1

package/dist/dialects/pg/relations.d.ts

@@ -1,9 +1,11 @@
 /**
- * `one` and `many` relations.
+ * `one`, `many`, and `manyThrough` relations.
  *
  * They name a table. `schema()` resolves the foreign key. An ambiguous key
- * is OKM1021. `manyThrough` arrives in 0.2. `morph` stays reserved.
+ * is OKM1021. `manyThrough` names the join table as well and carries its own
+ * resolver, so a schema without one does not pay for it. `morph` stays reserved.
  */
+import type { RelationModel } from "./model.js";
 /** A to-one relation. `field` is the local foreign key when the table has several. */
 export type OneRelation<TTable extends string = string> = {
     readonly kind: "one";
@@ -16,6 +18,46 @@ export type ManyRelation<TTable extends string = string> = {
     readonly table: TTable;
     readonly field: string | undefined;
 };
+/** A foreign key `schema()` resolved, as a relation resolver sees it. */
+export type RelationEdge = {
+    readonly fromTable: string;
+    readonly fromField: string;
+    readonly toTable: string;
+    /** Local SQL names, one column or a composite key. */
+    readonly local: readonly string[];
+    /** Referenced SQL names, in the same order. */
+    readonly remote: readonly string[];
+};
+/** What a relation's own resolver reads from `schema()`. */
+export type RelationScope = {
+    /** The table that declares the relation. */
+    readonly owner: string;
+    /** The relation name. */
+    readonly name: string;
+    readonly edges: readonly RelationEdge[];
+    /** Every table name in the schema, sorted. */
+    readonly tables: readonly string[];
+};
+/**
+ * A to-many relation through a join table.
+ *
+ * It is a {@link ManyRelation} to the types, so `include`, `has`, `none`, and
+ * `every` read it as one. `resolve` is what `schema()` calls in place of the
+ * foreign-key search that `many` uses.
+ */
+export type ManyThroughRelation<TTable extends string = string> = ManyRelation<TTable> & {
+    /** The join table. */
+    readonly through: string;
+    /** Turns this declaration into a resolved model. */
+    readonly resolve: (scope: RelationScope) => RelationModel;
+};
+/** Join-table foreign keys, named only when more than one points at a table. */
+export type ThroughKeys = {
+    /** The join table field that references the declaring table. */
+    readonly from?: string;
+    /** The join table field that references the related table. */
+    readonly to?: string;
+};
 /** A relation `table()` stores. */
 export type RelationCall = OneRelation | ManyRelation;
 /**
@@ -43,3 +85,18 @@ export declare function many<const TTable extends string>(table: TTable, field?:
  * @returns `true` for `one` and `many`
  */
 export declare function isRelationCall(value: unknown): value is RelationCall;
+/**
+ * Declares a to-many relation through a join table.
+ *
+ * The join table has one foreign key to the declaring table and one to the
+ * related table. Name `from` and `to` when a table has more than one. Tenancy
+ * and archivable apply to the join rows and to the related rows alike.
+ *
+ * @typeParam TTable - Related table
+ * @param table - Related table name
+ * @param options - The join table, and its foreign-key fields when ambiguous
+ * @returns The relation `schema()` resolves
+ */
+export declare function manyThrough<const TTable extends string>(table: TTable, options: {
+    readonly through: string;
+} & ThroughKeys): ManyThroughRelation<TTable>;

package/dist/dialects/pg/schema.d.ts

@@ -4,8 +4,11 @@
  * Work happens here, not in `table()` and not at import.
  */
 import type { Catalog } from "../../contracts/catalog/types.js";
-import { type TableModel } from "./model.js";
-import { type AnyTable } from "./table.js";
+import { type ClientGenerator } from "../../contracts/generator.js";
+import { type SchemaHook, type TableModel } from "./model.js";
+import type { FieldsOfList, HasArchive, PresetsOfList, Trait } from "./trait.js";
+import { type ColumnTenancy, type TenantFields } from "./tenancy.js";
+import { type AnyTable, type InsertFrom, type RowFrom, type UpdateFrom } from "./table.js";
 /** Codec defaults from spec section 6.6. */
 export type SchemaCodecs = {
     readonly bigint: "string" | "number" | "bigint";
@@ -33,8 +36,28 @@ export type SchemaInput<TTables extends readonly AnyTable[]> = {
         readonly timestamps?: SchemaCodecs["timestamps"];
     };
     readonly types?: "emitted" | "inferred";
-    readonly traits?: unknown;
-    readonly tenancy?: unknown;
+    /**
+     * What a bare `t.id()` means.
+     *
+     * `"uuidv7"` and `"uuidv4"` are database defaults. A client generator is
+     * filled on insert and stays out of the catalog. A column option wins.
+     */
+    readonly defaults?: {
+        readonly id?: "uuidv7" | "uuidv4" | ClientGenerator<string>;
+    };
+    /**
+     * Traits applied to every table.
+     *
+     * A table opts out with `omitDefaults` and a reason. A table's own `traits`
+     * are added as well.
+     */
+    readonly traits?: readonly Trait[];
+    /**
+     * Column tenancy.
+     *
+     * Every table gains the key unless it passes `global("reason")`.
+     */
+    readonly tenancy?: ColumnTenancy;
     readonly validation?: unknown;
     readonly extensions?: unknown;
     readonly functions?: unknown;
@@ -59,11 +82,68 @@ export type BuiltSchema<TTables extends readonly AnyTable[]> = {
     readonly codecs: SchemaCodecs;
     readonly requires: SchemaRequires | undefined;
     readonly tables: TTables;
+    /**
+     * Schema traits, when the call passed a non-empty list.
+     *
+     * Omitted otherwise, so a schema that uses no traits does not carry the key.
+     */
+    readonly traits?: readonly Trait[];
+    /**
+     * Column tenancy, when the call passed it.
+     *
+     * Omitted otherwise, so a schema with no tenancy does not carry the key.
+     */
+    readonly tenancy?: ColumnTenancy;
     /** Query model. Built once, beside the catalog document. */
     readonly model: {
         readonly [T in TTables[number] as T["~name"]]: TableModel;
     };
 };
+/**
+ * A schema whose tenant tables carry the tenant key on the row.
+ *
+ * A table marked `~global` keeps its own type. No tenancy leaves the schema
+ * type unchanged.
+ *
+ * @typeParam S - Schema type before tenancy
+ * @typeParam TTables - Tables in declaration order
+ * @typeParam TTenancy - Column tenancy, or `undefined`
+ */
+export type TenancySchema<S, TTables extends readonly AnyTable[], TTenancy> = TTenancy extends ColumnTenancy ? Omit<S, "~byName"> & {
+    readonly tenancy: TTenancy;
+    readonly "~byName": {
+        readonly [T in TTables[number] as T["~name"]]: T extends {
+            readonly "~global": string;
+        } ? T : T & {
+            readonly "~row": RowFrom<TenantFields<TTenancy["key"]>>;
+            readonly "~insert": InsertFrom<TenantFields<TTenancy["key"]>>;
+            readonly "~update": UpdateFrom<TenantFields<TTenancy["key"]>>;
+        };
+    };
+} : S;
+/**
+ * A schema whose default traits are part of every table's row type.
+ *
+ * A table with `omitDefaults` keeps its own type. An empty trait list does not
+ * change the schema type.
+ *
+ * @typeParam TTables - Tables in declaration order
+ * @typeParam TTraits - Schema default traits
+ */
+export type SchemaWithTraits<TTables extends readonly AnyTable[], TTraits extends readonly {
+    readonly fields: Readonly<Record<string, object>>;
+}[]> = [keyof FieldsOfList<TTraits> | keyof PresetsOfList<TTraits>] extends [never] ? BuiltSchema<TTables> : Omit<BuiltSchema<TTables>, "~byName"> & {
+    readonly "~byName": {
+        readonly [T in TTables[number] as T["~name"]]: ApplySchemaTraits<T, FieldsOfList<TTraits>, TTraits>;
+    };
+};
+type ApplySchemaTraits<TTable, TFields, TTraits> = TTable extends {
+    readonly "~omitDefaults": true;
+} ? TTable : TTable & {
+    readonly "~row": RowFrom<TFields>;
+    readonly "~insert": InsertFrom<TFields>;
+    readonly "~update": UpdateFrom<TFields>;
+} & HasArchive<TTraits> & PresetsOfList<TTraits>;
 /**
  * Compiles tables into a catalog.
  *
@@ -74,4 +154,28 @@ export type BuiltSchema<TTables extends readonly AnyTable[]> = {
  * @param config - Tables, casing, codecs, and the row-type mode
  * @returns The schema and its catalog
  */
-export declare function schema<const TTables extends readonly AnyTable[]>(config: SchemaInput<TTables>): BuiltSchema<TTables>;
+export declare function schema<const TTables extends readonly AnyTable[], const TTraits extends readonly {
+    readonly fields: Readonly<Record<string, object>>;
+}[], const TTenancy extends ColumnTenancy | undefined = undefined, const TValidation = undefined>(config: Omit<SchemaInput<TTables>, "traits" | "tenancy" | "validation"> & {
+    readonly traits: TTraits;
+    readonly tenancy?: TTenancy;
+    readonly validation?: TValidation;
+}): [TValidation] extends [undefined] ? TenancySchema<SchemaWithTraits<TTables, TTraits>, TTables, TTenancy> : TenancySchema<SchemaWithTraits<TTables, TTraits>, TTables, TTenancy> & {
+    readonly "~validation": TValidation;
+};
+export declare function schema<const TTables extends readonly AnyTable[], const TTenancy extends ColumnTenancy | undefined = undefined, const TValidation = undefined>(config: Omit<SchemaInput<TTables>, "tenancy" | "validation"> & {
+    readonly tenancy?: TTenancy;
+    readonly validation?: TValidation;
+}): [TValidation] extends [undefined] ? TenancySchema<BuiltSchema<TTables>, TTables, TTenancy> : TenancySchema<BuiltSchema<TTables>, TTables, TTenancy> & {
+    readonly "~validation": TValidation;
+};
+/**
+ * Registers a hook from an opt-in module.
+ *
+ * Core does not import that module. A featureless app never calls this, so
+ * the module that loads the validation engine stays out of its graph.
+ *
+ * @param hook - Called for the client and for each table
+ */
+export declare function addSchemaHook(hook: SchemaHook): void;
+export {};

package/dist/dialects/pg/table.d.ts

@@ -6,6 +6,8 @@
  */
 import { type ColumnInsertOf, type ColumnRowOf, type ColumnUpdateOf } from "./column.js";
 import { type RelationCall } from "./relations.js";
+import type { PresetMap } from "./preset.js";
+import { type FieldsOfList, type HasArchive, type PresetsOfList, type Trait } from "./trait.js";
 /**
  * A column as seen by `indexes` and `checks`.
  *
@@ -20,6 +22,12 @@ export type ColumnHandle = {
 export type IndexCall = {
     readonly columns: readonly string[];
     readonly isUnique: boolean;
+    /**
+     * Partial-index predicate, stored as the catalog wrote it.
+     *
+     * Absent on an ordinary index.
+     */
+    readonly predicate?: string;
     /**
      * Marks the index unique.
      *
@@ -52,16 +60,50 @@ export type TableOptions<TColumns> = {
     readonly unique?: {
         readonly [name: string]: readonly (keyof TColumns & string)[];
     };
+    /**
+     * Composite primary key, in column order.
+     *
+     * A single-column key can use this or `.primaryKey()` on the column.
+     * One table has one primary key.
+     */
+    readonly primaryKey?: readonly (keyof TColumns & string)[];
     readonly sqlName?: string;
     readonly renamedFrom?: string;
     readonly comment?: string;
     readonly validate?: unknown;
     readonly validation?: unknown;
-    readonly traits?: unknown;
-    readonly omitDefaults?: unknown;
-    readonly tenancy?: unknown;
+    /**
+     * Traits added to this table.
+     *
+     * Schema default traits are added as well, unless `omitDefaults` is set.
+     */
+    readonly traits?: readonly Trait[];
+    /**
+     * Skip schema default traits.
+     *
+     * The value is the reason. An empty reason is rejected when the schema is built.
+     */
+    readonly omitDefaults?: string;
+    /**
+     * Opts this table out of schema tenancy.
+     *
+     * `global("reason")` is the opt-out. `{ via }` arrives later.
+     */
+    readonly tenancy?: {
+        readonly kind: "global";
+        readonly reason: string;
+    } | {
+        readonly via: string;
+    };
     readonly computed?: unknown;
-    readonly presets?: unknown;
+    /**
+     * Named, typed refinements called as `tasks.pending()`.
+     *
+     * A preset gets a builder and its own arguments and returns the builder.
+     * The builder only adds predicates. A name that is a client method or is
+     * reserved is OKM1040.
+     */
+    readonly presets?: PresetMap<RowFrom<TColumns>>;
     readonly policies?: unknown;
     readonly reference?: unknown;
     /** `one` and `many`. Other relation kinds stay reserved. */
@@ -85,16 +127,39 @@ export type Handles<TColumns> = {
  * @typeParam TColumns - Column builders
  * @typeParam TRelations - Relations declared on this table
  */
-export type Table<TName extends string, TColumns, TRelations extends Readonly<Record<string, RelationCall>> = Readonly<Record<string, never>>> = {
+export type Table<TName extends string, TColumns, TRelations extends Readonly<Record<string, RelationCall>> = Readonly<Record<string, never>>, TKey extends string = never, TOptions = object> = {
     readonly "~name": TName;
     readonly "~columns": TColumns;
     readonly "~row": RowFrom<TColumns>;
     readonly "~insert": InsertFrom<TColumns>;
-    readonly "~update": UpdateFrom<TColumns>;
+    readonly "~update": UpdateFrom<TColumns, TKey>;
     readonly "~relations": TRelations;
     readonly name: TName;
     readonly columns: TColumns;
-    readonly options?: TableOptions<TColumns>;
+    readonly options?: TOptions;
+    /**
+     * Allowlisted client filters.
+     *
+     * A hidden field in `allow`, `sort`, or `relations` throws OKM1123 here.
+     * `parse` loads the parser on first use.
+     *
+     * @param spec - Fields, operators, and sorts the caller may send
+     * @returns A parser for one request object
+     */
+    filters(spec: FilterSpec): {
+        parse(query: unknown): Promise<ParsedFilters>;
+    };
+};
+/** What {@link Table.filters} accepts. */
+export type FilterSpec = {
+    readonly allow?: Readonly<Record<string, readonly string[]>>;
+    readonly sort?: readonly string[];
+    readonly relations?: Readonly<Record<string, readonly string[]>>;
+};
+/** `where` and `orderBy` a caller can spread into `find`. */
+export type ParsedFilters = {
+    readonly where: Readonly<Record<string, unknown>>;
+    readonly orderBy?: Readonly<Record<string, "asc" | "desc">>;
 };
 /**
  * Any table `schema()` can compile.
@@ -108,6 +173,8 @@ export type AnyTable = {
     readonly name: string;
     readonly columns: Readonly<Record<string, object>>;
     readonly options?: object;
+    /** `file.ts:line` of the `table()` call. Not part of the catalog hash. */
+    readonly source?: string;
 };
 /**
  * Row shape. Hidden columns are omitted.
@@ -130,8 +197,8 @@ export type InsertFrom<TColumns> = {
  *
  * @typeParam TColumns - Column builders
  */
-export type UpdateFrom<TColumns> = {
-    readonly [K in keyof TColumns as ColumnUpdateOf<TColumns[K]> extends never ? never : K]: ColumnUpdateOf<TColumns[K]>;
+export type UpdateFrom<TColumns, TKey extends string = never> = {
+    readonly [K in keyof TColumns as K extends TKey ? never : ColumnUpdateOf<TColumns[K]> extends never ? never : K]: ColumnUpdateOf<TColumns[K]>;
 };
 /**
  * Declares a table.
@@ -145,8 +212,8 @@ export type UpdateFrom<TColumns> = {
  * @param options - Indexes, checks, unique constraints, and names
  * @returns The table
  */
-export declare function table<const TName extends string, const TColumns extends Readonly<Record<string, object>>>(name: TName, columns: TColumns): Table<TName, TColumns, Readonly<Record<string, never>>>;
-export declare function table<const TName extends string, const TColumns extends Readonly<Record<string, object>>, const TOptions extends TableOptions<TColumns>>(name: TName, columns: TColumns, options: TOptions): Table<TName, TColumns, RelationsOf<TOptions>>;
+export declare function table<const TName extends string, const TColumns extends Readonly<Record<string, object>>>(name: TName, columns: TColumns): Table<TName, TColumns, Readonly<Record<string, never>>, never>;
+export declare function table<const TName extends string, const TColumns extends Readonly<Record<string, object>>, const TOptions extends TableOptions<TColumns>>(name: TName, columns: TColumns, options: TOptions): DeclaredTable<TName, TColumns, TOptions>;
 /**
  * Relation map stored on a table.
  *
@@ -158,6 +225,58 @@ export declare function table<const TName extends string, const TColumns extends
 type RelationsOf<TOptions> = TOptions extends {
     readonly relations: infer R;
 } ? R extends Readonly<Record<string, RelationCall>> ? R : Readonly<Record<string, never>> : Readonly<Record<string, never>>;
+/**
+ * Column names listed in a table's `primaryKey` option.
+ *
+ * Absent when the option is omitted, so a table without it does not change
+ * its update shape.
+ *
+ * @typeParam TOptions - Options argument
+ */
+type PrimaryOf<TOptions> = TOptions extends {
+    readonly primaryKey: infer K;
+} ? K extends readonly (infer F)[] ? Extract<F, string> : never : never;
+/**
+ * Table type callers see, including trait fields and an opt-out of schema traits.
+ *
+ * @typeParam TName - Table name
+ * @typeParam TColumns - Column builders
+ * @typeParam TOptions - Options argument
+ */
+type DeclaredTable<TName extends string, TColumns, TOptions> = Table<TName, TColumns, RelationsOf<TOptions>, PrimaryOf<TOptions>, NoInfer<TOptions>> & TraitShapes<TColumns, TOptions> & ArchiveFlag<TOptions> & PresetFlag<TOptions> & OmitFlag<TOptions> & GlobalFlag<TOptions>;
+type ArchiveFlag<TOptions> = TOptions extends {
+    readonly traits: infer TTraits;
+} ? HasArchive<TTraits> : unknown;
+/** `{ "~presets" }` from the table's own `presets` and its traits' presets, when there are any. */
+type PresetFlag<TOptions> = (TOptions extends {
+    readonly presets: infer TPresets;
+} ? {
+    readonly "~presets": TPresets;
+} : unknown) & (TOptions extends {
+    readonly traits: infer TTraits;
+} ? PresetsOfList<TTraits> : unknown);
+type OmitFlag<TOptions> = TOptions extends {
+    readonly omitDefaults: string;
+} ? {
+    readonly "~omitDefaults": true;
+} : unknown;
+type GlobalFlag<TOptions> = TOptions extends {
+    readonly tenancy: {
+        readonly kind: "global";
+        readonly reason: infer TReason;
+    };
+} ? {
+    readonly "~global": TReason;
+} : unknown;
+type TraitShapes<TColumns, TOptions> = TOptions extends {
+    readonly traits: infer TTraits;
+} ? TTraits extends readonly {
+    readonly fields: Readonly<Record<string, object>>;
+}[] ? keyof FieldsOfList<TTraits> extends never ? unknown : {
+    readonly "~row": RowFrom<TColumns> & RowFrom<FieldsOfList<TTraits>>;
+    readonly "~insert": InsertFrom<TColumns> & InsertFrom<FieldsOfList<TTraits>>;
+    readonly "~update": UpdateFrom<TColumns, PrimaryOf<TOptions>> & UpdateFrom<FieldsOfList<TTraits>>;
+} : unknown : unknown;
 /**
  * Declares an index from column handles.
  *

package/dist/dialects/pg/temporal.d.ts

@@ -86,21 +86,23 @@ export declare function encodeTimeZone(value: TimeWithOffset, precision?: TimePr
 /**
  * Decodes a time with offset.
  *
- * @param wire - Time text plus an offset
- * @returns Time and offset
+ * @param wire - Time text plus an offset, `±HH` as Postgres sends it or `±HH:MM`
+ * @returns Time and offset, the offset as `±HH:MM`
  */
 export declare function decodeTimeZone(wire: string): TimeWithOffset;
 /**
  * Encodes a duration as an ISO-8601 duration.
  *
  * @param value - Duration
- * @returns ISO-8601 text Postgres accepts for interval
+ * @returns ISO-8601 text Postgres accepts for interval, with a sign on each field when negative
  */
 export declare function encodeDuration(value: Temporal.Duration): string;
 /**
- * Decodes an ISO-8601 duration.
+ * Decodes an interval as Postgres sends it: `1 year 2 mons 3 days 04:05:06.5`,
+ * `01:30:00`, or an ISO-8601 duration. A part may carry a sign. Parts of
+ * different signs (`1 day -01:00:00`) cannot be one `Temporal.Duration`.
  *
- * @param wire - Duration text
+ * @param wire - Interval text
  * @returns A duration
  */
 export declare function decodeDuration(wire: string): Temporal.Duration;
@@ -202,10 +204,10 @@ declare global {
         };
         readonly Duration: {
             /**
-             * @param item - ISO-8601 duration
+             * @param item - ISO-8601 duration, or numeric fields
              * @returns A duration
              */
-            from(item: string): Temporal.Duration;
+            from(item: string | Readonly<Record<string, number>>): Temporal.Duration;
         };
     };
 }

package/dist/dialects/pg/tenancy.d.ts

@@ -0,0 +1,94 @@
+/**
+ * The tenancy object `schema()` calls once.
+ *
+ * The methods live on the value `columnTenancy()` returns from `okmodel/tenancy`.
+ * This file only names them. An application that never imports that subpath
+ * does not load them.
+ */
+import type { ColumnBuilder, FlagTrue, PlainFlags } from "./column.js";
+import type { SchemaHookCtx } from "./model.js";
+import type { AnyTable } from "./table.js";
+/**
+ * A guarded uuid column, one per tenant table.
+ *
+ * Insert and update omit it. The client fills it from the scope.
+ */
+export type TenantFields<Key extends string> = {
+    readonly [K in Key]: ColumnBuilder<string, FlagTrue<PlainFlags, "guarded">>;
+};
+/** One tenant value, or a reason for leaving the scope. The value is not a cache key. */
+export type TenantCall = {
+    readonly value: string;
+} | {
+    readonly unscoped: string;
+};
+/** Text the scope predicate writes. The planner's sink has these methods. */
+export type TenancyText = {
+    text(value: string): void;
+    param(encoded: string): void;
+    mark(token: string): void;
+};
+/** `for()` and `unscoped()` plus the table names the root client keeps. */
+export type TenancyClient = {
+    readonly names: readonly string[];
+    readonly for?: (input: unknown) => unknown;
+    readonly unscoped?: (reason: string) => unknown;
+};
+/** One inspect rule the tenancy object recorded. */
+export type TenancyRule = {
+    readonly rule: string;
+    readonly contribution: string;
+    readonly provenance: string;
+    readonly source?: string;
+};
+/**
+ * Column tenancy passed to `schema({ tenancy })`.
+ *
+ * `columnTenancy()` from `okmodel/tenancy` builds it. `rewrite` runs once,
+ * before compile. The other methods are the planner and the client.
+ */
+export type ColumnTenancy = {
+    readonly key: string;
+    readonly type: "uuid";
+    readonly strategy: "column";
+    /** Tables with the tenant column, widened uniques, and composite references. */
+    rewrite(tables: readonly AnyTable[]): readonly AnyTable[];
+    /** The guarded uuid column, for emitted row types. */
+    column(): object;
+    predicate(input: {
+        readonly table: string;
+        readonly fieldSql: (field: string) => string | undefined;
+        readonly encode: ((value: unknown) => string) | undefined;
+        readonly alias: string;
+        readonly appended: boolean;
+        readonly scope: TenantCall | undefined;
+        readonly sink: TenancyText;
+    }): boolean;
+    guard(table: string, field: string, kind: "where" | "insert" | "update"): void;
+    stamp(table: string, rows: Record<string, unknown>[], scope: TenantCall | undefined): void;
+    client(input: {
+        readonly names: readonly string[];
+        readonly scoped: boolean;
+        readonly open: (scope: TenantCall) => unknown;
+    }): TenancyClient;
+    rules(table: string, source: string | undefined, scope: TenantCall | undefined): readonly TenancyRule[];
+    /**
+     * Attaches `for()` and `unscoped()` on the root client.
+     *
+     * The same hook archivable uses for its table methods.
+     *
+     * @param target - The client object
+     * @param ctx - Names, scope, and the table map
+     */
+    hook(target: Record<string, unknown>, ctx: SchemaHookCtx): void;
+    missing(table: string): never;
+};
+/**
+ * Reads `schema({ tenancy })`.
+ *
+ * Omitted stays `undefined`. Anything else must be `columnTenancy()`.
+ *
+ * @param value - The option the caller passed
+ * @returns The tenancy object, or `undefined`
+ */
+export declare function readTenancy(value: unknown): ColumnTenancy | undefined;

package/dist/dialects/pg/through.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Resolver and emitter of a `manyThrough` relation.
+ *
+ * The relation object carries both. `schema()` calls the resolver, and the
+ * planner calls the emitter with its own helpers, so a schema that has no
+ * `manyThrough` ships none of this. A join row or target in another tenant or
+ * archived never shows: the same planner predicates apply to both tables.
+ */
+import type { RelationScope } from "./relations.js";
+import type { RelationModel } from "./model.js";
+/**
+ * Resolves a `manyThrough` declaration against the schema's foreign keys.
+ *
+ * @param scope - What `schema()` knows
+ * @param table - Related table name
+ * @param through - Join table name
+ * @param from - Join table field that references the declaring table, when ambiguous
+ * @param to - Join table field that references the related table, when ambiguous
+ * @returns The resolved relation, carrying its emitter
+ */
+export declare function resolveThrough(scope: RelationScope, table: string, through: string, from: string | undefined, to: string | undefined): RelationModel;