@vibeorm/schema 4.2.0 → 4.3.0

package/dist/capabilities.d.ts

@@ -6,6 +6,7 @@
  * runtime, migrate, generator and tooling share their identity.
  */
 import type { Dialect } from "./ir.ts";
+import type { PredicateCapabilityTable, PredicateNumericType } from "./predicate.ts";
 /** Full-text engines the `search` extension can target. */
 export type FullTextEngine = "bm25" | "tsvector" | "fts5" | "fulltext";
 /**
@@ -40,6 +41,20 @@ export type AdvisoryLockMode = "exclusive" | "shared";
  */
 export type TimeOfDayType = "time" | "timetz";
 export type DialectCapabilities = {
+    /** Functional BTree keys on qualified engine versions, subject to scalar/storage admission. */
+    readonly expressionIndexes: boolean;
+    /** Core-owned stored generated columns. */
+    readonly generatedColumns: boolean;
+    /** Independent generated-expression normalization strategy. */
+    readonly generatedColumnNormalization: "rollback" | "temporary" | "sourceText";
+    /** Declared row UPDATE/DELETE prohibition. */
+    readonly rowRuleAppendOnly: boolean;
+    /** Declared explicit fixed-column groups. */
+    readonly rowRuleFixed: boolean;
+    /** Declared whole-row protection with explicit exceptions. */
+    readonly rowRuleRowFixed: boolean;
+    /** Declared creation- or field-activated whole-row protection. */
+    readonly rowRuleFrozen: boolean;
     /** Fixed PostgreSQL model/module placement and namespace ownership. */
     readonly fixedNamespaces: boolean;
     /** Precise exclusions for objects managed by another DDL owner. */
@@ -53,6 +68,10 @@ export type DialectCapabilities = {
     readonly checkNormalization: "rollback" | "temporary" | "sourceText";
     /** Typed JSON text, text length and fail-closed boolean expressions in CHECKs. */
     readonly schemaCheckExpressions: boolean;
+    /** Per-node admission; host availability is checked separately. */
+    readonly predicateExpressions: PredicateCapabilityTable;
+    /** Same-family arithmetic supported without implicit numeric promotion. */
+    readonly predicateArithmeticTypes: readonly PredicateNumericType[];
     /** Native database row policies; PGlite additionally needs a verified restricted role. */
     readonly nativeRowLevelSecurity: boolean;
     /** INSERT/UPDATE/DELETE ... RETURNING. False ⇒ insertId + re-select fallback. */
@@ -113,6 +132,8 @@ export type DialectCapabilities = {
      * when the schema is validated. Values are strings in JavaScript everywhere.
      */
     readonly uuidColumns: "native" | "text" | "unsupported";
+    /** String-backed Gregorian calendar days: native DATE, or TEXT with an owned CHECK on SQLite. */
+    readonly localDateColumns: boolean;
 };
 export declare const POSTGRES_CAPABILITIES: DialectCapabilities;
 export declare const SQLITE_CAPABILITIES: DialectCapabilities;

package/dist/check-rules.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Check rules — the common row rules a schema author declares by NAME
+ * (`.nonNegative()`, `allOrNone`, a presence table) instead of writing the
+ * boolean formula out by hand.
+ *
+ * DATA only, like `predicate.ts`: each rule expands into ONE `PredicateIR`,
+ * which the ordinary renderer (`renderPredicate` in @vibeorm/sql) turns into
+ * the CHECK body. Nothing here knows a dialect or a model; the DSL resolves
+ * names, validates the rule against the model and then calls
+ * {@link checkRulePredicate}.
+ *
+ * The expansion forms are a stability contract. Migrations compare the
+ * rendered text, so changing a form re-creates every user's CHECK. The renderer
+ * catalog (`packages/sql/tests/catalog/predicate-cases.ts`) pins each one.
+ */
+import type { PredicateComparisonOp, PredicateIR } from "./predicate.ts";
+/** A literal a rule compares against. BigInt and Decimal values travel as exact decimal text. */
+export type CheckRuleLiteral = string | number | boolean;
+/** The column-group rules: which optional columns may be set together. */
+export type CheckRuleGroupKind = "allOrNone" | "exactlyOne" | "atMostOne" | "anySet";
+/**
+ * One check rule over LOGICAL field names.
+ *
+ * - `compare`: `field <op> value` (`nonNegative` is `gte 0`, `positive` is `gt 0`).
+ * - `range`: `field >= min AND field <= max`.
+ * - `oneOf`: `field IN (values)`.
+ * - `lengthAtMost`: `length(field) <= max` (PostgreSQL/PGlite CHECKs only).
+ * - `order`: `left <op> right`, two columns.
+ * - `allOrNone` / `exactlyOne` / `atMostOne` / `anySet`: how many of a column group are set.
+ * - `presence`: whether `field` is set while the enum column `by` holds a member —
+ *   NOT NULL for the `set` members, NULL for the `unset` members, free otherwise.
+ */
+export type CheckRule = {
+    readonly kind: "compare";
+    readonly field: string;
+    readonly op: PredicateComparisonOp;
+    readonly value: CheckRuleLiteral;
+} | {
+    readonly kind: "range";
+    readonly field: string;
+    readonly min: CheckRuleLiteral;
+    readonly max: CheckRuleLiteral;
+} | {
+    readonly kind: "oneOf";
+    readonly field: string;
+    readonly values: readonly CheckRuleLiteral[];
+} | {
+    readonly kind: "lengthAtMost";
+    readonly field: string;
+    readonly max: number;
+} | {
+    readonly kind: "order";
+    readonly left: string;
+    readonly op: "gt" | "gte" | "lt" | "lte";
+    readonly right: string;
+} | {
+    readonly kind: CheckRuleGroupKind;
+    readonly fields: readonly string[];
+} | {
+    readonly kind: "presence";
+    readonly by: string;
+    readonly field: string;
+    readonly set: readonly string[];
+    readonly unset: readonly string[];
+};
+/** The most columns a group rule takes: `exactlyOne` and `atMostOne` grow with the square of the count. */
+export declare const CHECK_RULE_GROUP_MAX: 8;
+/**
+ * Expand one rule into the predicate its CHECK holds.
+ *
+ * The forms, exactly as the renderer prints them. AND binds tighter than OR,
+ * so the renderer adds no parentheses around AND terms; the renderer catalog
+ * pins every form, and that text is frozen once released.
+ * - `allOrNone(a, b)`: `a IS NULL AND b IS NULL OR a IS NOT NULL AND b IS NOT NULL`.
+ * - `exactlyOne(a, b)`: one AND term per column — that column set, the others
+ *   empty, in declaration order — joined by OR.
+ * - `atMostOne(a, b)`: the `exactlyOne` terms, then the all-empty term.
+ * - `anySet(a, b)`: `a IS NOT NULL OR b IS NOT NULL`.
+ * - `presence`: `(by NOT IN (set) OR col IS NOT NULL) AND (by NOT IN (unset) OR col IS NULL)`.
+ *   An empty half is left out, and a lone half prints without parentheses;
+ *   one member prints as `by <> member`. It never names a free member, so
+ *   adding an enum member as free changes no CHECK text — PostgreSQL cannot
+ *   use a new enum member in the transaction that adds it.
+ *
+ * @throws VibeError `VIBE_SCHEMA_INVALID` for a structurally impossible rule
+ * (a group of fewer than two or repeated columns, a presence rule with no
+ * members, an empty `oneOf`).
+ */
+export declare function checkRulePredicate(params: {
+    rule: CheckRule;
+}): PredicateIR;
+//# sourceMappingURL=check-rules.d.ts.map

package/dist/generated-columns.d.ts

@@ -0,0 +1,39 @@
+import type { Dialect, SchemaIR } from "./ir.ts";
+/** A database-owned stored value; expression bytes are trusted physical SQL. */
+export type GeneratedColumnIR = {
+    readonly expression: string;
+    readonly storage: "stored";
+};
+/** Raw SQL authoring declaration; virtual storage is deliberately not exposed. */
+export type GeneratedColumnOptions = {
+    readonly sql: string;
+};
+/** One invalid generation declaration or incompatible field use. */
+export type GeneratedColumnValidationIssue = {
+    readonly rule: string;
+    readonly message: string;
+    readonly model?: string;
+    readonly field?: string;
+};
+/** Inspect canonical shape without running getters or rewriting SQL. */
+export declare function generatedColumnShapeIssue(params: {
+    readonly value: unknown;
+}): string | undefined;
+/** Validate, copy and freeze the canonical declaration. */
+export declare function assertGeneratedColumn(params: {
+    readonly value: unknown;
+}): GeneratedColumnIR;
+/** Validate the single-key DSL declaration and lower it to canonical stored generation. */
+export declare function generatedColumnFromSql(params: {
+    readonly value: unknown;
+}): GeneratedColumnIR;
+/** Collect all structural conflicts after complete model metadata is available. */
+export declare function validateGeneratedColumns(params: {
+    readonly schema: SchemaIR;
+}): readonly GeneratedColumnValidationIssue[];
+/** Refuse invalid or unsupported generation before generating clients or migrations. */
+export declare function assertGeneratedColumns(params: {
+    readonly schema: SchemaIR;
+    readonly dialect?: Dialect;
+}): void;
+//# sourceMappingURL=generated-columns.d.ts.map

package/dist/index-expressions.d.ts

@@ -0,0 +1,73 @@
+import type { Dialect, IndexIR, IndexKeyTermIR, ModelIR, SchemaIR } from "./ir.ts";
+/** An invalid functional-key declaration, reported without evaluating executable data. */
+export type IndexExpressionValidationIssue = {
+    readonly rule: string;
+    readonly message: string;
+    readonly model: string;
+    readonly feature?: string;
+};
+/** Presence is decisive: a malformed empty expression list is not a plain unique. */
+export declare function isExpressionIndex(params: {
+    readonly index: Pick<IndexIR, "expressions">;
+}): boolean;
+/** Resolve the complete ordered key without mutating the legacy named-field representation. */
+export declare function indexKeyTerms(params: {
+    readonly index: Pick<IndexIR, "fields" | "expressions">;
+}): readonly IndexKeyTermIR[];
+/** Exact first-seen logical dependencies; undefined means opaque raw SQL, not no dependencies. */
+export declare function indexKeyFieldNames(params: {
+    readonly index: Pick<IndexIR, "fields" | "expressions">;
+}): readonly string[] | undefined;
+/** Ordered scalar structure/carriers, direction, predicate and flags, without rendering SQL. */
+export declare function indexKeyDefinitionKey(params: {
+    readonly index: IndexIR;
+    readonly model?: Pick<ModelIR, "name" | "fields">;
+}): string;
+/** Conservative utf8mb4 bounds of a modern InnoDB functional key; schema admission and SQL rendering share this one table. */
+export declare const MYSQL_FUNCTIONAL_KEY_LIMITS: {
+    readonly bytes: number;
+    readonly bytesPerCharacter: number;
+    readonly defaultStringLength: number;
+    readonly arithmeticBytes: number;
+    readonly intBytes: number;
+    readonly wideBytes: number;
+    readonly decimalBytes: number;
+    readonly enumBytes: number;
+    readonly booleanBytes: number;
+};
+/** Complete MySQL key width, the first storage refusal, or `raw` when trusted SQL makes the width unknowable. */
+export type MysqlIndexKeyWidth = {
+    readonly kind: "bytes";
+    readonly bytes: number;
+} | {
+    readonly kind: "raw";
+} | {
+    readonly kind: "refused";
+    readonly field: string;
+    readonly feature: string;
+};
+/** The one MySQL expression-key storage rule; `generate` and migration planning both call it. */
+export declare function mysqlIndexKeyWidth(params: {
+    readonly terms: readonly IndexKeyTermIR[];
+    readonly model: Pick<ModelIR, "fields">;
+}): MysqlIndexKeyWidth;
+/** Collect expression-only shape/type/usage issues, leaving plain schemas unchanged. */
+export declare function validateIndexExpressions(params: {
+    readonly schema: SchemaIR;
+    readonly dialect: Dialect;
+}): readonly IndexExpressionValidationIssue[];
+/** Refuse untrusted shape, non-scalar operands and unsupported keys before SQL or client generation. */
+export declare function assertIndexExpressions(params: {
+    readonly schema: SchemaIR;
+    readonly dialect: Dialect;
+}): void;
+/** Shared DSL source for complete keys; scalar data and raw SQL are never executed by the printer. */
+export declare function indexKeyDsl(params: {
+    readonly term: IndexKeyTermIR;
+    readonly model: Pick<ModelIR, "name" | "fields">;
+}): string;
+/** Canonical VibeORM extended Prisma source; raw SQL retains its exact bytes. */
+export declare function indexKeyPrisma(params: {
+    readonly term: IndexKeyTermIR;
+}): string;
+//# sourceMappingURL=index-expressions.d.ts.map

package/dist/index.d.ts

@@ -5,18 +5,28 @@
 export { SQL_NAMESPACES, assertSqlNamespace, qualifiedSqlName, sqlNamespaceIssue } from "./namespaces.ts";
 export { assertNativeRlsAdmission } from "./native-rls-admission.ts";
 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 { 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";
+export { assertGeneratedColumn, assertGeneratedColumns, generatedColumnFromSql, generatedColumnShapeIssue, validateGeneratedColumns } from "./generated-columns.ts";
 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 { DIALECTS, ENUM_STORAGES, enumStorageOf, fieldTypeIdentity, isEnumType, providerToDialect } from "./ir.ts";
-export type { CascadeAction, DatasourceIR, DefaultValueIR, Dialect, EnumIR, EnumStorage, ExtensionDeclIR, FieldIR, FieldType, JsonSchemaRefIR, IndexFieldIR, CheckIR, IndexIR, IndexKind, ModelIR, Provider, RelationIR, RelationType, ScalarType, SchemaIR, } from "./ir.ts";
-export { PREDICATE_COMPARISON_OPS, assertPredicateCapabilities, inspectPredicate, isPredicateFieldRef, predicateFieldNames, predicateKey } from "./predicate.ts";
-export type { PredicateComparisonOp, PredicateExpression, PredicateFieldRef, PredicateIR, PredicateOperand, PredicateValue } from "./predicate.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 { 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";
+export type { CheckRule, CheckRuleGroupKind, CheckRuleLiteral } from "./check-rules.ts";
+export { resolveOnDelete, resolveOnUpdate, resolveReferentialActions } from "./referential-actions.ts";
 export { assertMigrationObjects, isSqlObjectDefinition, isSqlObjectIdentity, sqlObjectKey, sqlObjectNamespace } from "./migration-objects.ts";
 export type { MigrationObjectIR, QualifiedSqlName, SqlObjectDefinition, SqlObjectDefinitionFormat, SqlObjectFacts, SqlObjectIdentity } from "./migration-objects.ts";
 export type { AdvisoryLockMode, DialectCapabilities, FullTextEngine, RowLockStrength, RowLockWaitPolicy, TimeOfDayType, } from "./capabilities.ts";
 export { timeOfDayType } from "./time-of-day.ts";
+export { isLocalDateField, isCanonicalLocalDate, localDateCheckName } from "./local-date.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 { decodePrismaString, encodePrismaString, exactDecimalLiteral, exactIntegerLiteral } from "./prisma-literal.ts";
@@ -29,7 +39,7 @@ export { RESERVED_ENUM_NAMES, assertValidSchemaIR, validateSchemaIR } from "./va
 export type { ValidationIssue } from "./validate.ts";
 export { implicitJoinTable } from "./m2m.ts";
 export type { ImplicitJoinTable } from "./m2m.ts";
-export { IDENTIFIER_LIMITS, assertIdentifierFits, defaultForeignKeyName, defaultIndexName, defaultPrimaryKeyName, fitDefaultName, identifierLength, implicitJoinTableObjectNames, postgresGeneratedObjectName, } from "./physical-names.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 type { NativeRlsIR, RlsContextFieldIR, RlsContextIR, RlsContextRefIR, RlsContextScalar, RlsPolicyIR } from "./ir.ts";
 export { DIALECT_CAPABILITIES, MYSQL_CAPABILITIES, POSTGRES_CAPABILITIES, SQLITE_CAPABILITIES } from "./capabilities.ts";
@@ -38,4 +48,5 @@ export type { RlsContextReason } from "./errors.ts";
 export { isImplicitManyToManyRelation, validateRlsContextIR } from "./validate.ts";
 export { scalarListDefault, serializeJsonDefault } from "./default-values.ts";
 export { assertJsonSchemaRef, hasJsonSchemaAnnotation, jsonSchemaRefIssue, jsonTypeAnnotationIssue, jsonTypeAnnotationRef, normalizeJsonSchemaRef } from "./json-schema-ref.ts";
+export { assertValidatorRef, hasValidatorAnnotation, normalizeValidatorRef, validatorRefIssue } from "./validator-ref.ts";
 //# sourceMappingURL=index.d.ts.map