@vibeorm/schema 5.9.0 → 5.11.0

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/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

@@ -50,7 +50,10 @@ export declare function generatedTypeNames(params: {
 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.9.0",
+  "version": "5.11.0",
   "description": "Canonical schema IR, validation, dialect/capability types, and error codes for VibeORM v2",
   "keywords": [
     "orm",