@vibeorm/schema 5.8.0 → 5.10.0

package/dist/capabilities.d.ts

@@ -61,6 +61,10 @@ export type DialectCapabilities = {
     readonly externalObjects: boolean;
     /** Qualified PostgreSQL index operator classes. */
     readonly indexOperatorClasses: boolean;
+    /** Non-key `INCLUDE (…)` columns on an index (covering indexes). */
+    readonly indexIncludeColumns: boolean;
+    /** Declared table storage parameters (`fillfactor`, autovacuum, `toast.` …): `WITH (…)` and `ALTER TABLE … SET/RESET (…)`. */
+    readonly tableStorageParameters: boolean;
     /** Explicit database-normalized CHECK inspection; text-only engines never guess equivalence. */
     /** PostgreSQL GiST exclusion constraints and their shared extension requirement. */
     readonly exclusionConstraints: boolean;
@@ -151,6 +155,22 @@ export type DialectCapabilities = {
      * built.
      */
     readonly dateTruncation: boolean;
+    /**
+     * How a filtered aggregate (`_filtered` on `aggregate` and `groupBy`)
+     * renders. `"filterClause"`: the standard `AGG(x) FILTER (WHERE …)`
+     * (SQLite 3.30 or later). `"caseWhen"`: `AGG(CASE WHEN … THEN x END)`, and
+     * `COUNT(*)` as `COUNT(CASE WHEN … THEN 1 END)`. Both give the same answers:
+     * a count of no matching row is 0, every other aggregate NULL.
+     */
+    readonly filteredAggregates: "filterClause" | "caseWhen";
+    /**
+     * `groupBy` grouping sets (`groupingSets`). `"groupingSets"`: any list of
+     * sets (`GROUP BY GROUPING SETS (…)`). `"rollup"`: only the rollup chain
+     * of `by` in order (`GROUP BY a, b WITH ROLLUP`). `"none"`: refused. Every
+     * other shape is refused with `VIBE_UNSUPPORTED_CAPABILITY` when the query
+     * is built.
+     */
+    readonly groupingSets: "groupingSets" | "rollup" | "none";
     /**
      * Row capture (`$transaction(…, { capture })`): a data-modifying statement
      * reports the declared columns of the rows it changed as they were before
@@ -160,6 +180,26 @@ export type DialectCapabilities = {
      * transaction opens.
      */
     readonly rowCapture: boolean;
+    /**
+     * `UPDATE … FROM (SELECT … FOR UPDATE) AS prev … RETURNING prev."col"`: an
+     * UPDATE's RETURNING may read the joined source, so ONE statement locks the
+     * row, writes it and returns its values from before the write (`update({
+     * previous })`). SQLite's RETURNING sees the target table alone and MySQL has
+     * no RETURNING: there the runtime reads the row (locking where the dialect
+     * 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;
 };
 export declare const POSTGRES_CAPABILITIES: DialectCapabilities;
 export declare const SQLITE_CAPABILITIES: DialectCapabilities;

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-include.d.ts

@@ -0,0 +1,18 @@
+import type { Dialect, SchemaIR } from "./ir.ts";
+/** Index kinds whose PostgreSQL access method stores `INCLUDE (…)` columns. */
+export declare const INCLUDE_INDEX_KINDS: readonly string[];
+/** Whether any index of the schema declares `INCLUDE` columns. */
+export declare function hasIndexIncludeColumns(params: {
+    schema: SchemaIR;
+}): boolean;
+/**
+ * Refuse `INCLUDE` columns that cannot be created: a malformed list, a dialect
+ * without covering indexes (`indexIncludeColumns`), an access method without
+ * them, an unknown field, a repeated field, or a field that is already a plain
+ * key column of the same index.
+ */
+export declare function assertIndexIncludeColumns(params: {
+    schema: SchemaIR;
+    dialect: Dialect;
+}): void;
+//# sourceMappingURL=index-include.d.ts.map

package/dist/index.d.ts

@@ -8,6 +8,9 @@ export { modelSqlNamespace } from "./model-sql-namespace.ts";
 export type { RowRuleIR, RowRuleWhenIR, RowRuleSpec, RowRuleCapability, RowRuleIdentities, RowRuleObject, RowRuleEvent, RowRuleValidationIssue } from "./row-rules.ts";
 export { MYSQL_ROW_RULE_MESSAGE_MAX_BYTES, mysqlRowRuleMessageByteLength, SQLITE_ROW_RULE_ERROR_PREFIX, sqliteRowRuleConstraint, rowRuleTriggerName, assertRowRuleReferentialActions, assertRowRuleCapability, assertRowRuleEquality, defaultRowRuleName, normalizeRowRules, rowRuleCapability, rowRuleGateField, rowRuleGeneratedFields, rowRuleIdentities, rowRuleObjectNames, rowRulePrismaAttribute, rowRuleProtectedFields, rowRuleShapeIssue, schemaRowRuleIdentities, validateRowRules } from "./row-rules.ts";
 export { assertIndexOperatorClasses } from "./index-operator-classes.ts";
+export { INCLUDE_INDEX_KINDS, assertIndexIncludeColumns, hasIndexIncludeColumns } from "./index-include.ts";
+export { TABLE_STORAGE_KEYS, TABLE_STORAGE_PARAMETERS, assertTableStorage, hasTableStorage, isToastStorageKey, parseTableStorageValue, renderTableStorageValue, tableStorageEntries, tableStorageKeyFromPrisma, tableStoragePrismaKey } from "./table-storage.ts";
+export type { TableStorageParameterSpec } from "./table-storage.ts";
 export { MYSQL_FUNCTIONAL_KEY_LIMITS, assertIndexExpressions, indexKeyDefinitionKey, indexKeyDsl, indexKeyFieldNames, indexKeyPrisma, indexKeyTerms, isExpressionIndex, mysqlIndexKeyWidth, validateIndexExpressions } from "./index-expressions.ts";
 export type { IndexExpressionValidationIssue, MysqlIndexKeyWidth } from "./index-expressions.ts";
 export type { GeneratedColumnIR, GeneratedColumnOptions, GeneratedColumnValidationIssue } from "./generated-columns.ts";
@@ -15,8 +18,9 @@ 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, } 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";
 export type { PredicateBooleanUsage, PredicateCapabilityInput, PredicateCapabilityIssue, PredicateCapabilityTable, PredicateComparisonOp, PredicateExpression, PredicateFieldRef, PredicateInspection, PredicateIR, PredicateNodeKind, PredicateNumericType, PredicateOperand, PredicateResultType, PredicateUsage, PredicateValue } from "./predicate.ts";
 export { CHECK_RULE_GROUP_MAX, checkRulePredicate } from "./check-rules.ts";
@@ -32,18 +36,25 @@ 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";
 export type { ExtensionArtifact, ExtensionArtifactOwner, ExtensionAttributeArgs, ExtensionAttributeValue, ExtensionClientContribution, ExtensionClientPlane, ExtensionDoctorCheck, ExtensionDoctorHook, ExtensionDoctorReport, ExtensionFieldType, ExtensionImportSpec, ExtensionManifestEntry, ExtensionMigratePlane, ExtensionModelAttribute, ExtensionModelTypeNames, ExtensionRegistry, ExtensionRuntimePlane, ExtensionSchemaContext, ExtensionSqlExecutor, ExtensionSqlPlane, ExtensionWhereOperator, SqlFragmentPart, SqlFragmentSpec, VibeExtension, } from "./extension.ts";
 export { buildComputedManifest, validateComputedConfig } from "./computed.ts";
 export type { ComputedConfig, ComputedFieldSpec, ComputedManifestEntry } from "./computed.ts";
-export { RESERVED_ENUM_NAMES, assertValidSchemaIR, validateSchemaIR } from "./validate.ts";
-export type { ValidationIssue } from "./validate.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";