@vibeorm/schema 5.7.0 → 5.9.0

package/dist/ir.d.ts

@@ -131,6 +131,16 @@ export type FieldIR = {
      * Absent = server/table default (LOWER() kept — conservative).
      */
     readonly collation?: string;
+    /**
+     * How a `BigInt` column reads in JavaScript (`@number`, `dsl.bigint({ mode: "number" })`).
+     * `"number"`: a safe `number` instead of a `bigint`, typed `number` in the
+     * generated client; a stored value beyond `Number.MAX_SAFE_INTEGER` (or below
+     * its negative) fails the read with `VIBE_DATA_INVALID`, and a write of an
+     * unsafe number refuses with `VIBE_VALIDATION`, never rounding. Aggregates
+     * that carry the field's type (`_sum`, `_min`, `_max`) follow it. Absent =
+     * `bigint`. No DDL: the column stays 8-byte.
+     */
+    readonly bigIntMode?: "number";
 };
 export type RelationType = "oneToOne" | "oneToMany" | "manyToOne" | "manyToMany";
 export type CascadeAction = "Cascade" | "Restrict" | "NoAction" | "SetNull" | "SetDefault";
@@ -154,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;
@@ -212,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";
@@ -296,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/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/validate.d.ts

@@ -23,6 +23,29 @@ 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;

package/package.json

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