@vibeorm/schema 5.9.0 → 5.11.0

package/dist/capabilities.d.ts

@@ -189,6 +189,39 @@ export type DialectCapabilities = {
      * can) and then writes it, inside the call's transaction.
      */
     readonly returningReadsJoinedSource: boolean;
+    /**
+     * `skipUnchanged: true` on `upsert` / `upsertMany`: a conflicting row whose
+     * every written column already holds the incoming value is not rewritten and
+     * keeps its `@updatedAt` stamp. PostgreSQL and SQLite put the comparison on
+     * the conflict arm's `WHERE`; MySQL's ON DUPLICATE KEY UPDATE has none, so
+     * the stamp's assignment goes first and keeps the stored stamp when the
+     * stored row equals the incoming one byte for byte (`IF(… <=> …, stamp, ?)`,
+     * assignments run left to right), and MySQL itself skips a row whose
+     * assignments change nothing. Without it `skipUnchanged` is refused.
+     */
+    readonly upsertSkipUnchanged: boolean;
+    /**
+     * Carrier rows: under the `"join"` relation strategy, the lists, counts and
+     * aggregates below a to-one that several rows of one statement share are
+     * built and sent once per distinct target. The first row of each target
+     * carries them (window ordinals over the statement's rows) in a lateral
+     * gated on "this row is the carrier", and the dialect's planner must not
+     * run that lateral for the other rows (PostgreSQL: a One-Time Filter).
+     * Without it such a level nests on a level of few rows and loads by key
+     * after the statement otherwise.
+     */
+    readonly carrierRows: boolean;
+    /**
+     * A dictionary of shared lists: under the `"join"` relation strategy, the
+     * lists, counts and aggregates below a to-one that sits under a list level
+     * are built and sent once per distinct target of the whole statement. The
+     * statement keeps its rows in a common table expression, reads the targets'
+     * keys back out of the JSON it built for them, builds one entry per
+     * distinct key and returns the entries on its first row. Without it such a
+     * level nests on a level of few rows and loads by key after the statement
+     * otherwise.
+     */
+    readonly sharedListDictionary: boolean;
 };
 export declare const POSTGRES_CAPABILITIES: DialectCapabilities;
 export declare const SQLITE_CAPABILITIES: DialectCapabilities;

package/dist/errors.d.ts

@@ -30,6 +30,17 @@ export declare const VIBE_ERROR_CODES: readonly [
 "VIBE_SCHEMA_INVALID", 
 /** Feature requested on a dialect that does not support it. */
 "VIBE_UNSUPPORTED_CAPABILITY", 
+/**
+ * One value of a statement's result passed the size limit the server sets
+ * for a single value, so the server could not send the result.
+ * `meta.limit` names the limit: `"max_allowed_packet"` on MySQL (a server
+ * setting, 64 MB by default) or `"MaxAllocSize"` on PostgreSQL (1 GB,
+ * fixed). `meta.relation` names the relation whose payload it was, where
+ * the runtime knows it. The `"join"` relation strategy sends the lists of a
+ * relation level as one JSON value; the `"query"` strategy reads them as
+ * rows and has no such limit.
+ */
+"VIBE_RESULT_TOO_LARGE", 
 /** Generated client is stale relative to config/schema — re-run generate. */
 "VIBE_STALE_CLIENT", 
 /** Configuration problem (vibeorm.config.ts, flags, env). */

package/dist/exclusion.d.ts

@@ -37,4 +37,12 @@ export type ExclusionIR = {
     readonly normalizationSource?: string;
     readonly catalogDefinition?: true;
 };
+/**
+ * The model fields an exclusion constraint compares, in declaration order: its
+ * keys' fields, then its range endpoints'. `undefined` when the constraint has
+ * no structured source (a definition read back from the catalog).
+ */
+export declare function exclusionFields(params: {
+    readonly exclusion: ExclusionIR;
+}): readonly string[] | undefined;
 //# sourceMappingURL=exclusion.d.ts.map

package/dist/extension.d.ts

@@ -326,11 +326,6 @@ export declare function buildExtensionRegistry(params: {
 }): ExtensionRegistry;
 /** An empty registry — the default when no extensions are configured. */
 export declare const EMPTY_EXTENSION_REGISTRY: ExtensionRegistry;
-/** Whether built-in declarations establish public-only physical ownership for this model. */
-export declare function hasPublicExtensionDeclaration(params: {
-    schema: SchemaIR;
-    model: string;
-}): boolean;
 /** Refuse placement that built-in extension SQL and ownership cannot preserve. */
 export declare function assertExtensionModelPlacement(params: {
     namespace?: string;

package/dist/failure-kind.d.ts

@@ -0,0 +1,72 @@
+/**
+ * What kind of failure an error is, read from its `code` and `meta` alone:
+ * the answer a retry policy or an error report needs, without matching
+ * message text.
+ */
+/**
+ * The closed set of `meta.reason` values a `VIBE_ADAPTER` error carries when
+ * the database could not be reached, the link died, the server is going away
+ * or no connection was free. Each such error also carries
+ * `meta.mayHaveReachedServer`: `false` only when the driver proves the
+ * statement was never sent, `true` otherwise.
+ */
+export declare const CONNECTION_FAILURE_REASONS: readonly [
+    "connection-refused",
+    "connection-timeout",
+    "connection-lost",
+    "connection-not-writable",
+    "acquire-timeout",
+    "pool-exhausted",
+    "pool-closed",
+    "too-many-connections",
+    "server-shutdown"
+];
+/** One member of {@link CONNECTION_FAILURE_REASONS}. */
+export type ConnectionFailureReason = (typeof CONNECTION_FAILURE_REASONS)[number];
+/** Whether `value` is one of {@link CONNECTION_FAILURE_REASONS}. */
+export declare function isConnectionFailureReason(params: {
+    value: unknown;
+}): boolean;
+/**
+ * The kinds {@link failureKindOf} answers:
+ *
+ * - `"connection"`: the database could not be reached, the link died, the
+ *   server is going away or no connection was free. `meta.reason` says which
+ *   and `meta.mayHaveReachedServer` whether the statement can have run.
+ * - `"conflict"`: the engine rolled the transaction back to resolve a
+ *   conflict with another one (deadlock, serialization failure, SQLite's busy
+ *   database file). Running the whole transaction again is the remedy.
+ * - `"timeout"`: a statement or transaction deadline ran out and the work was
+ *   cancelled before it committed.
+ * - `"constraint"`: the database refused the data: a unique, foreign-key,
+ *   exclusion, CHECK or NOT NULL constraint, or a declared row rule. Retrying
+ *   the same data fails the same way.
+ */
+export declare const FAILURE_KINDS: readonly ["connection", "conflict", "timeout", "constraint"];
+/** One member of {@link FAILURE_KINDS}. */
+export type FailureKind = (typeof FAILURE_KINDS)[number];
+/**
+ * The kind of failure `error` is, or `undefined` when it is none of
+ * {@link FAILURE_KINDS} (a bug, bad input caught before the database, a
+ * refusal by a restricted handle, a lock that was not available, a commit whose
+ * outcome is unknown). Read from the error's `code` and `meta` only, never from
+ * its message or its `cause`; an error that wraps a VibeORM error is not
+ * unwrapped. Any object with a VibeORM `code` and a `meta` object is read, so a
+ * second installed copy of `@vibeorm/schema` answers the same.
+ *
+ * It agrees with `transactionOutcomeOf`: `"conflict"` and `"timeout"` are
+ * failures that ended a transaction before it committed, and a `COMMIT` whose
+ * reply was lost is `VIBE_TRANSACTION` with `meta.reason:
+ * "transaction-outcome-unknown"`, which answers `undefined`. Decide a retry
+ * of a whole transaction from `transactionOutcomeOf`, of one statement from
+ * `meta.mayHaveReachedServer`.
+ *
+ * @example
+ * const kind = failureKindOf({ error });
+ * if (kind === "conflict") return runAgain();
+ * if (kind === "connection" && (error as VibeError).meta.mayHaveReachedServer === false) return retryLater();
+ */
+export declare function failureKindOf(params: {
+    error: unknown;
+}): FailureKind | undefined;
+//# sourceMappingURL=failure-kind.d.ts.map

package/dist/index.d.ts

@@ -18,6 +18,7 @@ export { assertGeneratedColumn, assertGeneratedColumns, generatedColumnFromSql,
 export type { DatabaseModuleOptions, DatabaseModuleManifest, DatabaseModuleArtifact } from "./database-module.ts";
 export { prepareDatabaseModuleSchema } from "./module-schema.ts";
 export type { ExclusionIR, ExclusionSpec, ExclusionKey, ExclusionEndpoint } from "./exclusion.ts";
+export { exclusionFields } from "./exclusion.ts";
 export { DIALECTS, ENUM_STORAGES, enumStorageOf, fieldTypeIdentity, isEnumType, providerToDialect } from "./ir.ts";
 export type { CascadeAction, DatasourceIR, DefaultValueIR, Dialect, EnumIR, EnumStorage, ExtensionDeclIR, FieldIR, FieldType, JsonSchemaRefIR, ValidatorRefIR, IndexFieldIR, IndexKeyTermIR, CheckIR, IndexIR, IndexKind, ModelIR, Provider, RelationIR, RelationType, ScalarType, SchemaIR, TableStorageParameters, TableStorageValue, VacuumStorageParameters, } from "./ir.ts";
 export { PREDICATE_COMPARISON_OPS, assertPredicateCapabilities, inspectPredicate, inspectPredicateExpression, isPredicateFieldRef, predicateCapabilityIssue, predicateFieldNames, predicateKey } from "./predicate.ts";
@@ -35,6 +36,9 @@ export { isLocalDateField, isCanonicalLocalDate, localDateCheckName } from "./lo
 export { dialectCollation, isMysqlCollationName } from "./collation.ts";
 export { READ_ONLY_REFUSAL_REASONS, ReadOnlyClientError, SCOPED_REFUSAL_REASONS, ScopedQueryError, VIBE_ERROR_CODES, VibeError, internalError, invalidStoredData, unsupportedCapability, } from "./errors.ts";
 export type { ReadOnlyRefusalReason, ScopedRefusalReason, VibeErrorCode } from "./errors.ts";
+export { CONNECTION_FAILURE_REASONS, FAILURE_KINDS, failureKindOf, isConnectionFailureReason } from "./failure-kind.ts";
+export type { ConnectionFailureReason, FailureKind } from "./failure-kind.ts";
+export { didYouMean, editDistance, isUnknownNameRefusal, suggestName, withSuggestion } from "./suggest.ts";
 export { decodePrismaString, encodePrismaString, exactDecimalLiteral, exactIntegerLiteral } from "./prisma-literal.ts";
 export { RESERVED_CLIENT_NAMES, RESERVED_DELEGATE_NAMES, isReservedClientName, isReservedDelegateName, } from "./reserved.ts";
 export { assertExtensionModelPlacement, assertExtensionPlacement, EMPTY_EXTENSION_REGISTRY, buildExtensionRegistry, defineExtension, extensionDeclarations, extensionManifestEntry, extensionOptionsHash, mergeExtensionDeclarations, } from "./extension.ts";
@@ -43,10 +47,14 @@ export { buildComputedManifest, validateComputedConfig } from "./computed.ts";
 export type { ComputedConfig, ComputedFieldSpec, ComputedManifestEntry } from "./computed.ts";
 export { RESERVED_ENUM_NAMES, assertValidSchemaIR, generatedTypeNames, validateSchemaIR } from "./validate.ts";
 export type { DisambiguatedTypeSuffix, GeneratedTypeNames, ValidationIssue } from "./validate.ts";
+export { sealSchemaIR } from "./sealed.ts";
 export { implicitJoinTable } from "./m2m.ts";
 export type { ImplicitJoinTable } from "./m2m.ts";
 export { IDENTIFIER_LIMITS, assertIdentifierFits, defaultForeignKeyName, defaultIndexName, defaultExpressionIndexName, defaultPrimaryKeyName, fitDefaultName, identifierLength, implicitJoinTableObjectNames, postgresGeneratedObjectName, } from "./physical-names.ts";
 export type { IdentifierLimit, ImplicitJoinTableObjectNames } from "./physical-names.ts";
+export { modelUniqueKeys } from "./unique-keys.ts";
+export { normalizeWhere } from "./partial-predicate.ts";
+export type { UniqueKeyIR } from "./unique-keys.ts";
 export type { NativeRlsIR, RlsContextFieldIR, RlsContextIR, RlsContextRefIR, RlsContextScalar, RlsPolicyIR } from "./ir.ts";
 export { DIALECT_CAPABILITIES, MYSQL_CAPABILITIES, POSTGRES_CAPABILITIES, SQLITE_CAPABILITIES } from "./capabilities.ts";
 export { RLS_CONTEXT_REASONS, RlsContextError } from "./errors.ts";