@vibeorm/schema 5.0.0 → 5.2.0

package/dist/capabilities.d.ts

@@ -90,6 +90,14 @@ export type DialectCapabilities = {
     readonly partialIndexes: boolean;
     /** Named-constraint conflict targets (`ON CONFLICT ON CONSTRAINT …`). */
     readonly conflictTargetConstraint: boolean;
+    /**
+     * A guard on the conflict's update arm: `ON CONFLICT (…) DO UPDATE SET …
+     * WHERE <guard>` — the existing row is updated (and returned) only when the
+     * guard admits it, in the same atomic statement. Tenant-scoped (`$scoped`)
+     * and `$withPolicy` upserts use it; MySQL's `ON DUPLICATE KEY UPDATE` has no
+     * WHERE, so there they keep the transactional find-then-write path.
+     */
+    readonly conflictUpdateWhere: boolean;
     /** DDL participates in transactions (mysql auto-commits DDL). */
     readonly transactionalDdl: boolean;
     /** createManyAndReturn support (requires multi-row RETURNING). */
@@ -134,6 +142,13 @@ export type DialectCapabilities = {
     readonly uuidColumns: "native" | "text" | "unsupported";
     /** String-backed Gregorian calendar days: native DATE, or TEXT with an owned CHECK on SQLite. */
     readonly localDateColumns: boolean;
+    /**
+     * Calendar truncation of a timestamp in a named time zone — the `groupBy`
+     * key `{ field, truncate, timeZone }` (PostgreSQL `date_trunc` with a zone,
+     * PostgreSQL 12 or later). Without it the key is refused when the query is
+     * built.
+     */
+    readonly dateTruncation: boolean;
 };
 export declare const POSTGRES_CAPABILITIES: DialectCapabilities;
 export declare const SQLITE_CAPABILITIES: DialectCapabilities;

package/dist/date-truncation.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Calendar truncation of a timestamp — the `groupBy` key form
+ * `{ field, truncate, timeZone }` (one group per hour, day, ISO week, month
+ * or year of a `DateTime` field, in a named time zone).
+ *
+ * ONE rule decides which fields can take it: the runtime's refusal, the
+ * renderer's expression and the generator's `by` type all call
+ * {@link dateTruncationStorage}, so they can never disagree.
+ */
+import type { FieldType } from "./ir.ts";
+/** A calendar period a timestamp can be truncated to (PostgreSQL `date_trunc` units; `week` is the ISO week, starting on Monday). */
+export type DateTruncationUnit = "hour" | "day" | "week" | "month" | "year";
+/** Every {@link DateTruncationUnit}, in increasing length. */
+export declare const DATE_TRUNCATION_UNITS: readonly DateTruncationUnit[];
+/**
+ * How a truncatable field stores its value on PostgreSQL. `"timestamptz"`: an
+ * instant (the canonical `DateTime` mapping, `@db.Timestamptz(n)`).
+ * `"timestamp"`: a zone-less column (`@db.Timestamp(n)`), which by VibeORM's
+ * contract holds the UTC wall-clock of the instant on every postgres driver.
+ */
+export type DateTruncationStorage = "timestamptz" | "timestamp";
+/**
+ * The storage form of a field a timestamp truncation can read, or `undefined`
+ * when the field cannot be truncated: not a `DateTime`, a list, an
+ * unsupported type, or a native type that is not a timestamp (`@db.Date`,
+ * `@db.Time`, `@db.Timetz`). A `DateTime` without a native type takes the
+ * canonical mapping, `timestamptz`.
+ */
+export declare function dateTruncationStorage(params: {
+    readonly field: {
+        readonly type: FieldType;
+        readonly nativeType?: string;
+        readonly isList: boolean;
+        readonly isUnsupported?: boolean;
+    };
+}): DateTruncationStorage | undefined;
+//# sourceMappingURL=date-truncation.d.ts.map

package/dist/errors.d.ts

@@ -130,8 +130,11 @@ export declare function internalError(params: {
  * Stable lifecycle categories; metadata never includes identity values.
  * `"null-claim"`: a key listed in `nativeRls.refuseNull` is bound to `null` and
  * the operation reaches a model whose rule reads it (or runs raw SQL).
+ * `"context-switched"`: the handle's transaction is running a `tx.$inContext`
+ * switch under another identity; the handle (and every handle derived from it)
+ * is refused until the switch has restored its claims.
  */
-export declare const RLS_CONTEXT_REASONS: readonly ["missing", "invalid", "expired", "conflicting", "null-claim"];
+export declare const RLS_CONTEXT_REASONS: readonly ["missing", "invalid", "expired", "conflicting", "null-claim", "context-switched"];
 export type RlsContextReason = (typeof RLS_CONTEXT_REASONS)[number];
 /** Native RLS binding/lifecycle failure, distinct from database permissions. */
 export declare class RlsContextError extends VibeError {

package/dist/index.d.ts

@@ -26,6 +26,8 @@ export { assertMigrationObjects, isSqlObjectDefinition, isSqlObjectIdentity, sql
 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 { DATE_TRUNCATION_UNITS, dateTruncationStorage } from "./date-truncation.ts";
+export type { DateTruncationStorage, DateTruncationUnit } from "./date-truncation.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";

package/dist/index.js

@@ -71,7 +71,8 @@ var RLS_CONTEXT_REASONS = Object.freeze([
   "invalid",
   "expired",
   "conflicting",
-  "null-claim"
+  "null-claim",
+  "context-switched"
 ]);
 
 class RlsContextError extends VibeError {
@@ -447,6 +448,7 @@ var POSTGRES_CAPABILITIES = Object.freeze({
   distinctOn: true,
   partialIndexes: true,
   conflictTargetConstraint: true,
+  conflictUpdateWhere: true,
   transactionalDdl: true,
   createManyAndReturn: true,
   jsonColumnType: true,
@@ -457,7 +459,8 @@ var POSTGRES_CAPABILITIES = Object.freeze({
   advisoryLocks: true,
   timeOfDayTypes: Object.freeze(["time", "timetz"]),
   uuidColumns: "native",
-  localDateColumns: true
+  localDateColumns: true,
+  dateTruncation: true
 });
 var SQLITE_CAPABILITIES = Object.freeze({
   rowRuleAppendOnly: true,
@@ -485,6 +488,7 @@ var SQLITE_CAPABILITIES = Object.freeze({
   distinctOn: false,
   partialIndexes: true,
   conflictTargetConstraint: false,
+  conflictUpdateWhere: true,
   transactionalDdl: true,
   createManyAndReturn: true,
   jsonColumnType: false,
@@ -495,7 +499,8 @@ var SQLITE_CAPABILITIES = Object.freeze({
   advisoryLocks: false,
   timeOfDayTypes: Object.freeze([]),
   uuidColumns: "text",
-  localDateColumns: true
+  localDateColumns: true,
+  dateTruncation: false
 });
 var MYSQL_CAPABILITIES = Object.freeze({
   rowRuleAppendOnly: true,
@@ -523,6 +528,7 @@ var MYSQL_CAPABILITIES = Object.freeze({
   distinctOn: false,
   partialIndexes: false,
   conflictTargetConstraint: false,
+  conflictUpdateWhere: false,
   transactionalDdl: false,
   createManyAndReturn: false,
   jsonColumnType: true,
@@ -533,7 +539,8 @@ var MYSQL_CAPABILITIES = Object.freeze({
   advisoryLocks: false,
   timeOfDayTypes: Object.freeze(["time"]),
   uuidColumns: "unsupported",
-  localDateColumns: true
+  localDateColumns: true,
+  dateTruncation: false
 });
 var DIALECT_CAPABILITIES = Object.freeze({
   postgres: POSTGRES_CAPABILITIES,
@@ -1936,6 +1943,11 @@ function validateRowRules(params) {
 function wellFormedName(params) {
   return [...params.name].every((character) => character.length !== 1 || character.charCodeAt(0) < 55296 || character.charCodeAt(0) > 57343);
 }
+var REPEATED_RULE_ADVICE = Object.freeze({
+  appendOnly: "Keep one: it already refuses every UPDATE and DELETE.",
+  rowFixed: "Merge them into one rule whose except list holds only the fields both leave mutable.",
+  frozen: "Merge them into one rule, or protect the fields of a later stage with a fixed rule gated by onceSet."
+});
 function validateRowRulesWithLookup(params) {
   const { model, dialect } = params;
   const rules = model.rowRules;
@@ -1947,7 +1959,7 @@ function validateRowRulesWithLookup(params) {
   const add = (params) => {
     issues.push({ rule: params.rule ?? "row-rule-invalid", model: model.name, ...params });
   };
-  const seenKinds = new Set;
+  const firstOfKind = new Map;
   const seenDefinitions = new Set;
   const seenNames = new Set;
   for (const value of rules) {
@@ -1958,18 +1970,22 @@ function validateRowRulesWithLookup(params) {
     }
     const rule = value;
     const generated = rule.kind === "appendOnly" ? new Set : params.generatedFields({ model });
-    if (seenNames.has(rule.name))
+    const first = rule.kind === "fixed" ? undefined : firstOfKind.get(rule.kind);
+    if (first !== undefined && rule.kind !== "fixed")
+      add({ message: `Model "${model.name}" declares more than one ${rule.kind} row rule (${first}, ${rule.name}). A model takes at most one ${rule.kind} rule; only fixed rules may repeat. ${REPEATED_RULE_ADVICE[rule.kind]}` });
+    else if (seenNames.has(rule.name))
       add({ rule: "row-rule-name-collision", message: `Row rules share the physical stem ${rule.name}; supply an explicit, distinct name stem` });
     seenNames.add(rule.name);
     if (model.isView)
       add({ message: "Row rules require a stored table, not a view" });
-    if (rule.kind !== "fixed" && seenKinds.has(rule.kind))
-      add({ message: `Only one ${rule.kind} row rule is allowed per model` });
-    seenKinds.add(rule.kind);
-    const definition = rule.kind === "fixed" ? JSON.stringify([rule.kind, [...rule.columns].sort(), rule.when]) : rule.kind;
-    if (seenDefinitions.has(definition))
-      add({ message: `Duplicate ${rule.kind} row-rule declaration` });
-    seenDefinitions.add(definition);
+    if (rule.kind !== "fixed" && first === undefined)
+      firstOfKind.set(rule.kind, rule.name);
+    if (rule.kind === "fixed") {
+      const definition = JSON.stringify([rule.kind, [...rule.columns].sort(), rule.when]);
+      if (seenDefinitions.has(definition))
+        add({ message: "Duplicate fixed row-rule declaration" });
+      seenDefinitions.add(definition);
+    }
     const pair = rowRuleObjectNames({ rule });
     const names = dialect === "postgres" ? [pair.functionName, pair.triggerName] : (rule.kind === "appendOnly" ? ["update", "delete"] : ["update"]).map((event) => rowRuleTriggerName({ rule, event }));
     for (const name of names) {
@@ -2004,7 +2020,7 @@ function validateRowRulesWithLookup(params) {
     if (rule.kind !== "appendOnly" && (rule.kind === "fixed" && rule.columns.length === 0 || protectedFieldsWithGenerated({ model, rule, generated }).length === 0))
       add({ message: `${rule.kind} requires at least one protected stored field` });
   }
-  if (seenKinds.has("appendOnly") && rules.length > 1)
+  if (firstOfKind.has("appendOnly") && rules.length > 1)
     add({ message: "appendOnly cannot combine with other row rules; it already refuses every UPDATE and DELETE" });
   return issues;
 }
@@ -2414,6 +2430,23 @@ function timeOfDayType(params) {
     return "timetz";
   return "time";
 }
+// packages/schema/src/date-truncation.ts
+var DATE_TRUNCATION_UNITS = Object.freeze(["hour", "day", "week", "month", "year"]);
+var ZONED_NATIVE_TYPE = /^timestamptz(?:\(\d+\))?$|^timestamp(?:\(\d+\))?withtimezone$/;
+var ZONE_LESS_NATIVE_TYPE = /^timestamp(?:\(\d+\))?(?:withouttimezone)?$/;
+function dateTruncationStorage(params) {
+  const { field } = params;
+  if (field.type !== "DateTime" || field.isList || field.isUnsupported === true)
+    return;
+  if (field.nativeType === undefined)
+    return "timestamptz";
+  const native = field.nativeType.toLowerCase().replace(/\s+/g, "");
+  if (ZONED_NATIVE_TYPE.test(native))
+    return "timestamptz";
+  if (ZONE_LESS_NATIVE_TYPE.test(native))
+    return "timestamp";
+  return;
+}
 // packages/schema/src/computed.ts
 function buildComputedManifest(params) {
   const { computed } = params;
@@ -2778,6 +2811,8 @@ var RESERVED_ENUM_NAMES = [
   "KeysetPage",
   "KeysetOptions",
   "RowLockRequest",
+  "GroupByTruncateUnit",
+  "GroupByKeyName",
   "JsonValue",
   "InputJsonValue",
   "InputJsonArray",
@@ -2810,6 +2845,7 @@ var RESERVED_ENUM_NAMES = [
   "Skip",
   "TransactionOptions",
   "CallbackTransactionOptions",
+  "RawStatement",
   "AdvisoryLockOptions",
   "StatementDiagnosticsOptions",
   "SchemaIR",
@@ -2849,6 +2885,11 @@ var GENERATED_TYPE_NAMES = {
     "ScalarOrderByInput",
     "RelationOrderByInput",
     "RelationFindManyArgs",
+    "RelationAggregateOrderByInput",
+    "RelationAvgOrderByInput",
+    "RelationSumOrderByInput",
+    "RelationMinOrderByInput",
+    "RelationMaxOrderByInput",
     "CreateInput",
     "UncheckedCreateInput",
     "CreateManyInput",
@@ -2872,6 +2913,7 @@ var GENERATED_TYPE_NAMES = {
     "MaxAggregateOrderByInput",
     "HavingInput",
     "GroupByOrderByInput",
+    "GroupByTruncatedKey",
     "FindManyArgs",
     "FindPageArgs",
     "FindFirstArgs",
@@ -3004,7 +3046,10 @@ function validateGeneratedNames(params) {
     owners.set("BoundVibeClientInstance", "native RLS client");
     owners.set("BoundVibeTransactionClientInstance", "native RLS client");
     owners.set("OperatorVibeClientInstance", "native RLS client");
+    owners.set("OperatorVibeTransactionClientInstance", "native RLS client");
   }
+  if (schema.models.some((model) => model.policy !== undefined))
+    owners.set("PolicyClientInstance", "policy client");
   if (schema.models.some((model) => model.fields.some((field) => isLocalDateField({ field })))) {
     for (const name of ["LocalDate", "LocalDateFilter", "LocalDateNullableFilter"])
       owners.set(name, "local-date filters");
@@ -4368,6 +4413,7 @@ function validRlsForeignKey(params) {
 }
 export {
   CHECK_RULE_GROUP_MAX,
+  DATE_TRUNCATION_UNITS,
   DIALECTS,
   DIALECT_CAPABILITIES,
   EMPTY_EXTENSION_REGISTRY,
@@ -4412,6 +4458,7 @@ export {
   buildComputedManifest,
   buildExtensionRegistry,
   checkRulePredicate,
+  dateTruncationStorage,
   decodePrismaString,
   defaultExpressionIndexName,
   defaultForeignKeyName,
@@ -4502,4 +4549,4 @@ export {
   validatorRefIssue
 };
 
-//# debugId=BE4A4B85E399756C64756E2164756E21
+//# debugId=6A81F5FFEA4B498F64756E2164756E21