@vibeorm/schema 5.8.0 → 5.10.0

package/dist/ir.d.ts

@@ -164,6 +164,16 @@ export type RelationIR = {
     readonly fields?: readonly string[];
     /** Referenced columns on the target model (FK side only). */
     readonly references?: readonly string[];
+    /**
+     * Correlation of a to-one without `fields` whose target declares no foreign
+     * key back: `fields` on this model pair, member by member, with `references`,
+     * a unique key of the target that holds the same values. No constraint backs
+     * it, and migrate emits none; only relation loading reads it.
+     */
+    readonly inverseKey?: {
+        readonly fields: readonly string[];
+        readonly references: readonly string[];
+    };
     readonly onDelete?: CascadeAction;
     readonly onUpdate?: CascadeAction;
     readonly isList: boolean;
@@ -222,6 +232,13 @@ export type IndexIR = {
      * Unique indexes only; postgres 15+ (pglite included), capability-gated.
      */
     readonly nullsNotDistinct?: boolean;
+    /**
+     * Non-key columns stored in the index (`INCLUDE (…)`, a covering index), by
+     * field name, in order. Never a key column of the same index; absent when the
+     * index carries none, never empty. PostgreSQL btree, unique, GiST and SP-GiST
+     * indexes only (capability `indexIncludeColumns`).
+     */
+    readonly include?: readonly string[];
 };
 /** Identity scalars supported by native RLS; lists, enums, Json and Bytes refuse. */
 export type RlsContextScalar = "String" | "Boolean" | "Int" | "BigInt" | "Float" | "Decimal" | "DateTime";
@@ -306,9 +323,55 @@ export type ModelIR = {
         readonly fields: readonly string[];
         readonly clientName?: string;
     };
+    /**
+     * PostgreSQL table storage parameters (`@@storage(…)`), keyed by their
+     * PostgreSQL names; absent when the model declares none, never empty.
+     * Capability `tableStorageParameters`.
+     */
+    readonly storage?: TableStorageParameters;
+    /**
+     * Introspection only: `false` when the live PostgreSQL table has no TOAST
+     * table. PostgreSQL accepts and discards `toast.` parameters for such a
+     * table, so they cannot be read back or compared.
+     */
+    readonly catalogToastTable?: false;
     readonly isView: boolean;
     readonly documentation?: string;
 };
+/** A table storage parameter value: a number, a boolean, or an enum word (`vacuum_index_cleanup`). */
+export type TableStorageValue = number | boolean | string;
+/** Parameters PostgreSQL accepts for a table and, with a `toast.` prefix, for its TOAST table. */
+export type VacuumStorageParameters = {
+    readonly autovacuum_enabled?: boolean;
+    readonly vacuum_index_cleanup?: "auto" | "on" | "off";
+    readonly vacuum_truncate?: boolean;
+    readonly autovacuum_vacuum_threshold?: number;
+    readonly autovacuum_vacuum_scale_factor?: number;
+    readonly autovacuum_vacuum_insert_threshold?: number;
+    readonly autovacuum_vacuum_insert_scale_factor?: number;
+    readonly autovacuum_vacuum_cost_delay?: number;
+    readonly autovacuum_vacuum_cost_limit?: number;
+    readonly autovacuum_freeze_min_age?: number;
+    readonly autovacuum_freeze_max_age?: number;
+    readonly autovacuum_freeze_table_age?: number;
+    readonly autovacuum_multixact_freeze_min_age?: number;
+    readonly autovacuum_multixact_freeze_max_age?: number;
+    readonly autovacuum_multixact_freeze_table_age?: number;
+    readonly log_autovacuum_min_duration?: number;
+};
+/**
+ * PostgreSQL table storage parameters (CREATE TABLE "Storage Parameters"), by
+ * their PostgreSQL names. `toast.`-prefixed keys set the TOAST table's value.
+ */
+export type TableStorageParameters = VacuumStorageParameters & {
+    readonly fillfactor?: number;
+    readonly toast_tuple_target?: number;
+    readonly parallel_workers?: number;
+    readonly autovacuum_analyze_threshold?: number;
+    readonly autovacuum_analyze_scale_factor?: number;
+} & {
+    readonly [K in keyof VacuumStorageParameters as `toast.${K}`]?: VacuumStorageParameters[K];
+};
 /**
  * How an enum is physically stored.
  *

package/dist/native-rls-admission.d.ts

@@ -1,5 +1,5 @@
 import type { Dialect, SchemaIR } from "./ir.ts";
-/** Admit only the public-table native RLS contract shared by every consumer. */
+/** Admit only the public-table native RLS contract shared by every consumer (once per dialect for a sealed schema). */
 export declare function assertNativeRlsAdmission(params: {
     schema: SchemaIR;
     dialect?: Dialect;

package/dist/partial-predicate.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The comparison key of a partial index's predicate (`where:`): two spellings
+ * of one predicate are one database object. Migrate compares indexes by it and
+ * the unique-key enumeration dedupes by it, so both agree on which partial
+ * uniques are the same key.
+ */
+/**
+ * Comparison key for a partial-index predicate.
+ *
+ * Literal bytes, quoted identifier case and casts are semantic. Only the
+ * supported boolean structure is reparenthesized. Quoted and unquoted names
+ * may conservatively compare unequal; equivalence requires catalog evidence.
+ * Complex lexical forms remain opaque rather than claiming false convergence.
+ */
+export declare function normalizeWhere(params: {
+    where: string | undefined;
+}): string;
+//# sourceMappingURL=partial-predicate.d.ts.map

package/dist/reserved.d.ts

@@ -8,16 +8,6 @@
  */
 export declare const RESERVED_DELEGATE_NAMES: readonly string[];
 export declare const RESERVED_CLIENT_NAMES: readonly string[];
-/**
- * Column-name prefix reserved for VibeORM's own result projections — the M2M
- * join loader's `__vibe_parent` stitch key today, hidden order/stitch fields
- * generally. A user column with this prefix would collide with a projection
- * alias and be silently misgrouped or stripped, so schema validation refuses
- * it (`reserved-column-prefix`). Unreachable from `.prisma` field-name
- * grammar, reachable via `@map` or hand-built IR. Wave-C sqlite review,
- * finding 3.
- */
-export declare const RESERVED_COLUMN_PREFIX: string;
 export declare function isReservedDelegateName(params: {
     name: string;
 }): boolean;

package/dist/row-rules.d.ts

@@ -1,5 +1,5 @@
 import type { Dialect, FieldIR, ModelIR, SchemaIR } from "./ir.ts";
-import type { MigrationObjectIR, SqlObjectIdentity } from "./migration-objects.ts";
+import type { SqlObjectIdentity } from "./migration-objects.ts";
 /** A fixed group is protected from insertion, or after OLD's nullable gate is set. */
 export type RowRuleWhenIR = {
     readonly fromCreation: true;
@@ -121,26 +121,6 @@ export declare function rowRuleTriggerName(params: {
 export declare function rowRuleGateField(params: {
     rule: RowRuleIR | RowRuleSpec;
 }): string | undefined;
-type RowRuleOwnedObject = Pick<MigrationObjectIR, "id" | "identity">;
-/** Internal, invocation-local preparation shared by schema validation passes. */
-export type RowRuleValidationContext = {
-    readonly objects: () => readonly RowRuleOwnedObject[];
-    readonly generatedFields: (params: {
-        model: ModelIR;
-    }) => ReadonlySet<string>;
-    readonly validate: (params: {
-        model: ModelIR;
-    }) => readonly RowRuleValidationIssue[];
-    readonly assertEquality: (params: {
-        model: ModelIR;
-        rule: RowRuleIR;
-    }) => void;
-};
-/** Prepare registered ownership lazily; no row rules means no migration-object reads. */
-export declare function createRowRuleValidationContext(params: {
-    schema: SchemaIR;
-    dialect?: Dialect;
-}): RowRuleValidationContext;
 /** Authored generated-column ownership identities mapped to logical keys. */
 export declare function rowRuleGeneratedFields(params: {
     schema: SchemaIR;
@@ -194,5 +174,4 @@ export declare function assertRowRuleReferentialActions(params: {
 export declare function rowRulePrismaAttribute(params: {
     rule: RowRuleIR;
 }): string;
-export {};
 //# sourceMappingURL=row-rules.d.ts.map

package/dist/sealed.d.ts

@@ -0,0 +1,16 @@
+import type { SchemaIR } from "./ir.ts";
+/**
+ * A deep-frozen copy of a schema. Nothing can change a sealed schema, so
+ * `assertValidSchemaIR` validates it once and answers from memory afterwards —
+ * a consumer that checks a schema per operation (native RLS readiness, policy
+ * rendering) pays the validation once. The caller's schema stays as it was and
+ * keeps being validated on every call.
+ *
+ * A schema that holds anything but plain objects, arrays and primitives (a
+ * function, a class instance, a symbol) cannot be copied faithfully and is
+ * returned as it is.
+ */
+export declare function sealSchemaIR(params: {
+    schema: SchemaIR;
+}): SchemaIR;
+//# sourceMappingURL=sealed.d.ts.map

package/dist/suggest.d.ts

@@ -0,0 +1,53 @@
+/**
+ * "Did you mean …?" for a misspelled name: a field, relation, model, operator
+ * or argument keyword. Meant for refusal paths only — the caller computes it
+ * after a lookup already failed, never on a successful one.
+ */
+/**
+ * Edit distance with adjacent transpositions (optimal string alignment):
+ * `stauts` → `status` is one edit, not two.
+ */
+export declare function editDistance(params: {
+    from: string;
+    to: string;
+}): number;
+/**
+ * The one known name close to `name`, or `undefined`. Close means an edit
+ * distance (a transposition counts as one edit) of at most 2, or at most a
+ * third of the longer name's length, and less than `name`'s own length, so a
+ * one-letter typo never "suggests" an unrelated short name. When several names
+ * are equally close none is suggested: a wrong guess costs more than none.
+ *
+ * @example suggestName({ name: "stauts", candidates: ["id", "status", "total"] }) // "status"
+ */
+export declare function suggestName(params: {
+    readonly name: string;
+    readonly candidates: Iterable<string>;
+}): string | undefined;
+/** The message suffix for a {@link suggestName} result: ` — did you mean "status"?`, or `""` without one. */
+export declare function didYouMean(params: {
+    readonly suggestion: string | undefined;
+}): string;
+/**
+ * A refusal's message and meta with the {@link suggestName} result for `name`
+ * appended (`… — did you mean "status"?`, `meta.suggestion`), or unchanged
+ * when no single known name is close. The returned meta is marked as an
+ * unknown-name refusal's ({@link isUnknownNameRefusal}).
+ */
+export declare function withSuggestion(params: {
+    readonly message: string;
+    readonly meta: Record<string, unknown>;
+    readonly name: string;
+    readonly candidates: Iterable<string>;
+}): {
+    message: string;
+    meta: Record<string, unknown>;
+};
+/**
+ * Whether an error's `meta` is an unknown-name refusal's from
+ * {@link withSuggestion} — the errors a delegate call names its method on.
+ */
+export declare function isUnknownNameRefusal(params: {
+    readonly meta: object;
+}): boolean;
+//# sourceMappingURL=suggest.d.ts.map

package/dist/table-storage.d.ts

@@ -0,0 +1,66 @@
+import type { Dialect, ModelIR, SchemaIR, TableStorageValue } from "./ir.ts";
+/** How one storage parameter is typed and bounded (PostgreSQL `reloptions.c`). */
+export type TableStorageParameterSpec = {
+    readonly type: "integer" | "real" | "boolean" | "enum";
+    readonly min?: number;
+    readonly max?: number;
+    readonly values?: readonly string[];
+};
+/**
+ * Every table storage parameter a schema may declare, keyed by its PostgreSQL
+ * name (`toast.`-prefixed for the TOAST table), in the order DDL renders them.
+ * Parameters newer than PostgreSQL 13 (`autovacuum_vacuum_max_threshold`,
+ * `vacuum_max_eager_freeze_failure_rate`) and `user_catalog_table` are left out.
+ */
+export declare const TABLE_STORAGE_PARAMETERS: Readonly<Record<string, TableStorageParameterSpec>>;
+/** The declarable keys, in rendering order. */
+export declare const TABLE_STORAGE_KEYS: readonly string[];
+/** Whether a key sets the TOAST table's parameter rather than the table's own. */
+export declare function isToastStorageKey(params: {
+    key: string;
+}): boolean;
+/**
+ * The `.prisma` spelling of a key: an attribute argument name cannot hold a
+ * dot, so `toast.autovacuum_enabled` is written `toast_autovacuum_enabled`.
+ */
+export declare function tableStoragePrismaKey(params: {
+    key: string;
+}): string;
+/** The PostgreSQL key a `.prisma` argument name stands for; undefined when it names none. */
+export declare function tableStorageKeyFromPrisma(params: {
+    name: string;
+}): string | undefined;
+/**
+ * Read a parameter value written as text (a `.prisma` argument, a
+ * `pg_class.reloptions` entry) into its IR value: undefined when the key is
+ * unknown or the text is not a value of its type. Bounds are not checked here.
+ */
+export declare function parseTableStorageValue(params: {
+    key: string;
+    text: string;
+}): TableStorageValue | undefined;
+/** The SQL text of a value inside `WITH (…)` / `SET (…)`. */
+export declare function renderTableStorageValue(params: {
+    value: TableStorageValue;
+}): string;
+/** Whether any model of the schema declares storage parameters. */
+export declare function hasTableStorage(params: {
+    schema: SchemaIR;
+}): boolean;
+/**
+ * Refuse storage parameters that cannot be created: a malformed or empty
+ * record, a view, a dialect without them (`tableStorageParameters`), an
+ * unknown key, or a value of the wrong type or outside PostgreSQL's range.
+ */
+export declare function assertTableStorage(params: {
+    schema: SchemaIR;
+    dialect: Dialect;
+}): void;
+/**
+ * A model's parameters as `[key, value]` pairs in rendering order, unknown keys
+ * last so a printer never drops one silently; empty when it declares none.
+ */
+export declare function tableStorageEntries(params: {
+    model: Pick<ModelIR, "storage">;
+}): readonly (readonly [string, TableStorageValue])[];
+//# sourceMappingURL=table-storage.d.ts.map

package/dist/unique-keys.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Every unique key of a model — its primary key and each unique index migrate
+ * creates — with a stable LOGICAL key and the PHYSICAL name the dialect gives
+ * it. One enumeration for every consumer: the runtime's violation lookup and
+ * `db.<model>.uniques`, `describeSchema`, and the generator's declarations.
+ *
+ * Physical names come from the shared naming rule (`physical-names.ts`), and
+ * the set of objects follows migrate's own: declared unique indexes first, a
+ * duplicate definition collapses into the first, and a field `@unique` folds
+ * into a declared index over the same column (`@unique(map: "x")` is one
+ * index named `x`).
+ */
+import type { Dialect, ModelIR } from "./ir.ts";
+/** One unique key of a model. */
+export type UniqueKeyIR = {
+    /**
+     * Stable logical key: the declared selector name (`name:` on `@@id` /
+     * `@@unique`), else the field names joined with `_` — the key compound
+     * selectors use, and a field `@unique`'s field name. A key whose natural
+     * name an earlier key already holds is keyed by its physical name (the
+     * declared one, else the default unshortened): the same key on every dialect.
+     */
+    readonly key: string;
+    /**
+     * The physical name a violation of this key reports on the dialect: a
+     * catalog-backed constraint's name, else the index name. MySQL's primary
+     * key is `PRIMARY`; `null` for SQLite's primary key, which has no name.
+     */
+    readonly name: string | null;
+    /** Every physical name the database may report for this key (index and constraint), `name` first. */
+    readonly names: readonly string[];
+    /** Field names in key order; absent for an expression key. */
+    readonly fields?: readonly string[];
+    /** Fields an expression key reads, when they are known (never for raw SQL). */
+    readonly sourceFields?: readonly string[];
+    readonly primaryKey: boolean;
+    /** A partial unique (`where:`): it guards only the rows its predicate covers. */
+    readonly partial: boolean;
+};
+/**
+ * Every unique key of `model` on `dialect`, primary key first. A view has
+ * none. Implicit many-to-many join tables are not models and are not listed.
+ */
+export declare function modelUniqueKeys(params: {
+    readonly model: ModelIR;
+    readonly dialect: Dialect;
+}): readonly UniqueKeyIR[];
+//# sourceMappingURL=unique-keys.d.ts.map

package/dist/validate.d.ts

@@ -23,11 +23,37 @@ export type ValidationIssue = {
  * this list cannot silently fall behind the emitters.
  */
 export declare const RESERVED_ENUM_NAMES: readonly string[];
+/**
+ * A model type-name family the generator renames when another owner generates
+ * the same name (`Call`'s to-many `CallListRelationFilter` and `CallList`'s
+ * to-one `CallListRelationFilter`). Every emission site of these families reads
+ * its name from {@link generatedTypeNames}.
+ */
+export type DisambiguatedTypeSuffix = "ListRelationFilter" | "RelationFilter" | "RelationOrderByInput" | "RelationFindManyArgs" | "CreateArgs" | "UpdateArgs" | "UpdateWhereInput" | "UpsertArgs" | "DeleteArgs" | "CountArgs" | "CountSelect" | "AggregateArgs" | "ViewSelect" | "ViewInclude" | "ViewFindManyArgs" | "ViewFindUniqueArgs" | "ViewDelegate";
+/** The declared names of one schema's generated client, shared by validation and the generator. */
+export type GeneratedTypeNames = {
+    /** `<Model><Suffix>`, or `<Model>_<Suffix>` when an owner with a longer name keeps `<Model><Suffix>`. */
+    readonly model: (params: {
+        model: string;
+        suffix: DisambiguatedTypeSuffix;
+    }) => string;
+};
+/**
+ * The type names a valid schema's generated client declares. Validation
+ * reports the clashes this resolution cannot settle, so the generator only
+ * ever reads names that are unique.
+ */
+export declare function generatedTypeNames(params: {
+    schema: SchemaIR;
+}): GeneratedTypeNames;
 /** Validate a SchemaIR structurally; returns all issues found (empty = valid). */
 export declare function validateSchemaIR(params: {
     schema: SchemaIR;
 }): ValidationIssue[];
-/** Throw VIBE_SCHEMA_INVALID (with all issues in meta) if the schema is invalid. */
+/**
+ * Throw VIBE_SCHEMA_INVALID (with all issues in meta) if the schema is invalid.
+ * A schema sealed by `sealSchemaIR` is validated once; later calls return at once.
+ */
 export declare function assertValidSchemaIR(params: {
     schema: SchemaIR;
 }): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibeorm/schema",
-  "version": "5.8.0",
+  "version": "5.10.0",
   "description": "Canonical schema IR, validation, dialect/capability types, and error codes for VibeORM v2",
   "keywords": [
     "orm",