@vibeorm/schema 2.5.0 → 3.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 VibeORM contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/capabilities.d.ts

@@ -34,6 +34,11 @@ export type RowLockStrength = "update" | "noKeyUpdate" | "share" | "keyShare";
 export type RowLockWaitPolicy = "wait" | "nowait" | "skipLocked";
 /** Advisory locks are exclusive (one holder) or shared (many readers, no writer). */
 export type AdvisoryLockMode = "exclusive" | "shared";
+/**
+ * Time-of-day column types a `DateTime` field can declare: `@db.Time(n)`
+ * (`"time"`) and `@db.Timetz(n)` (`"timetz"`, a time with a UTC offset).
+ */
+export type TimeOfDayType = "time" | "timetz";
 export type DialectCapabilities = {
     /** Fixed PostgreSQL model/module placement and namespace ownership. */
     readonly fixedNamespaces: boolean;
@@ -91,6 +96,13 @@ export type DialectCapabilities = {
      * survives a rollback — so it does not satisfy this capability.
      */
     readonly advisoryLocks: boolean;
+    /**
+     * Time-of-day column types (`DateTime @db.Time` / `@db.Timetz`) this dialect
+     * can hold. A field declaring any other is refused when the schema is
+     * validated. Values follow one contract everywhere: the UTC time of day of
+     * the `Date` is written, and a read returns that time at `1970-01-01` UTC.
+     */
+    readonly timeOfDayTypes: readonly TimeOfDayType[];
 };
 export declare const POSTGRES_CAPABILITIES: DialectCapabilities;
 export declare const SQLITE_CAPABILITIES: DialectCapabilities;

package/dist/errors.d.ts

@@ -60,6 +60,16 @@ export declare const VIBE_ERROR_CODES: readonly [
 "VIBE_PERMISSION_DENIED", 
 /** Driver/connection failure not mapped to a more specific code. */
 "VIBE_ADAPTER", 
+/**
+ * The adapter was disconnected: `disconnect()` ends an adapter for good, so
+ * work it receives after that call refuses instead of opening a new pool or
+ * connection. `meta` is fixed — `{ driver, state }`, where `driver` names the
+ * adapter (`"pg"`, `"bun"`, `"mysql"`, `"pglite"`, `"sqlite"`,
+ * `"better-sqlite3"`) and `state` is `"closing"` (admitted work is still
+ * draining) or `"closed"`; never an address. Create a new adapter to connect
+ * again.
+ */
+"VIBE_ADAPTER_CLOSED", 
 /** Invariant broken inside VibeORM itself — always a bug, please report. */
 "VIBE_INTERNAL"];
 export type VibeErrorCode = (typeof VIBE_ERROR_CODES)[number];

package/dist/index.d.ts

@@ -13,7 +13,8 @@ export { PREDICATE_COMPARISON_OPS, isPredicateFieldRef, predicateFieldNames, pre
 export type { PredicateComparisonOp, PredicateFieldRef, PredicateIR, PredicateOperand, PredicateValue } from "./predicate.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, } from "./capabilities.ts";
+export type { AdvisoryLockMode, DialectCapabilities, FullTextEngine, RowLockStrength, RowLockWaitPolicy, TimeOfDayType, } from "./capabilities.ts";
+export { timeOfDayType } from "./time-of-day.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";

package/dist/index.js

@@ -19,6 +19,7 @@ var VIBE_ERROR_CODES = [
   "VIBE_RLS_CONTEXT",
   "VIBE_PERMISSION_DENIED",
   "VIBE_ADAPTER",
+  "VIBE_ADAPTER_CLOSED",
   "VIBE_INTERNAL"
 ];
 
@@ -275,7 +276,8 @@ var POSTGRES_CAPABILITIES = Object.freeze({
   fullTextEngines: Object.freeze(["bm25", "tsvector"]),
   rowLockStrengths: Object.freeze(["update", "noKeyUpdate", "share", "keyShare"]),
   rowLockWaitPolicies: Object.freeze(["wait", "nowait", "skipLocked"]),
-  advisoryLocks: true
+  advisoryLocks: true,
+  timeOfDayTypes: Object.freeze(["time", "timetz"])
 });
 var SQLITE_CAPABILITIES = Object.freeze({
   fixedNamespaces: false,
@@ -300,7 +302,8 @@ var SQLITE_CAPABILITIES = Object.freeze({
   fullTextEngines: Object.freeze(["fts5"]),
   rowLockStrengths: Object.freeze([]),
   rowLockWaitPolicies: Object.freeze([]),
-  advisoryLocks: false
+  advisoryLocks: false,
+  timeOfDayTypes: Object.freeze([])
 });
 var MYSQL_CAPABILITIES = Object.freeze({
   fixedNamespaces: false,
@@ -325,7 +328,8 @@ var MYSQL_CAPABILITIES = Object.freeze({
   fullTextEngines: Object.freeze(["fulltext"]),
   rowLockStrengths: Object.freeze(["update", "share"]),
   rowLockWaitPolicies: Object.freeze(["wait", "nowait", "skipLocked"]),
-  advisoryLocks: false
+  advisoryLocks: false,
+  timeOfDayTypes: Object.freeze(["time"])
 });
 var DIALECT_CAPABILITIES = Object.freeze({
   postgres: POSTGRES_CAPABILITIES,
@@ -649,6 +653,20 @@ function predicateKey(params) {
   };
   return encode(params.predicate);
 }
+// packages/schema/src/time-of-day.ts
+var TIME_OF_DAY_NATIVE_TYPE = /^time(tz)?(?:\(\d+\))?$|^time(?:\(\d+\))?with(out)?timezone$/;
+function timeOfDayType(params) {
+  if (params.nativeType === undefined)
+    return;
+  const match = TIME_OF_DAY_NATIVE_TYPE.exec(params.nativeType.toLowerCase().replace(/\s+/g, ""));
+  if (match === null)
+    return;
+  if (match[1] !== undefined)
+    return "timetz";
+  if (match[0].endsWith("withtimezone") && match[2] === undefined)
+    return "timetz";
+  return "time";
+}
 // packages/schema/src/prisma-literal.ts
 var STRING_ESCAPES = {
   '"': '"',
@@ -1113,6 +1131,11 @@ var RESERVED_ENUM_NAMES = [
   "UncertainKeys",
   "HasSelectedField",
   "Provided",
+  "SelectionMember",
+  "SelectionValue",
+  "BagKeys",
+  "IncludedRelation",
+  "IncludedCount",
   "ViewDelegateMap",
   "extensionManifest",
   "extensionMounts",
@@ -1226,6 +1249,18 @@ var GENERATED_TYPE_NAMES = {
     "SumAggregateInput",
     "MinAggregateInput",
     "MaxAggregateInput",
+    "CountAggregateHavingInput",
+    "AvgAggregateHavingInput",
+    "SumAggregateHavingInput",
+    "MinAggregateHavingInput",
+    "MaxAggregateHavingInput",
+    "CountAggregateOrderByInput",
+    "AvgAggregateOrderByInput",
+    "SumAggregateOrderByInput",
+    "MinAggregateOrderByInput",
+    "MaxAggregateOrderByInput",
+    "HavingInput",
+    "GroupByOrderByInput",
     "FindManyArgs",
     "FindPageArgs",
     "FindFirstArgs",
@@ -1254,6 +1289,7 @@ var GENERATED_TYPE_NAMES = {
     "AggregateSelection",
     "CountOutput",
     "RelationPayload",
+    "ResolvedSelection",
     "IncludePayload",
     "GetPayload",
     "AggregateResult",
@@ -1395,6 +1431,57 @@ function validateGeneratedNames(params) {
       register({ name: `${declared.name}${suffix}`, owner: `enum "${declared.name}"` });
   }
 }
+function foreignKeyKeys(params) {
+  const distinct = new Set;
+  const repeated = [];
+  for (const fields of params.keys) {
+    if (new Set(fields).size === fields.length)
+      distinct.add(JSON.stringify([...fields].sort()));
+    else
+      repeated.push(fields);
+  }
+  return { distinct, repeated };
+}
+function matchesForeignKey(params) {
+  if (params.keys.distinct.has(JSON.stringify([...params.references].sort())))
+    return true;
+  return params.keys.repeated.some((fields) => fields.length === params.references.length && fields.every((name) => params.references.includes(name)));
+}
+function referencesPartialOnly(params) {
+  const { target, references, schema, lookups } = params;
+  let partial = lookups.partialKeys.get(target);
+  if (partial === undefined) {
+    partial = foreignKeyKeys({ keys: target.indexes.filter((index) => index.kind === "unique" && (index.where !== undefined || index.wherePredicate !== undefined)).map((index) => index.fields.map((field) => field.name)) });
+    lookups.partialKeys.set(target, partial);
+  }
+  if (partial.distinct.size === 0 && partial.repeated.length === 0)
+    return false;
+  if (!matchesForeignKey({ keys: partial, references }))
+    return false;
+  let total = lookups.totalKeys.get(target);
+  if (total === undefined) {
+    total = foreignKeyKeys({ keys: [
+      ...target.fields.filter((field) => field.isId || field.isUnique).map((field) => [field.name]),
+      ...target.primaryKey === undefined ? [] : [target.primaryKey.fields],
+      ...target.indexes.filter((index) => index.kind === "unique" && index.where === undefined && index.wherePredicate === undefined).map((index) => index.fields.map((field) => field.name))
+    ] });
+    lookups.totalKeys.set(target, total);
+  }
+  if (matchesForeignKey({ keys: total, references }))
+    return false;
+  if (lookups.independentTables === undefined) {
+    const tables = new Set;
+    for (const object of schema.migrationObjects ?? []) {
+      const identity = object.identity;
+      if (identity.kind === "index" || identity.kind === "constraint" && (identity.constraintType === "unique" || identity.constraintType === "primaryKey")) {
+        tables.add(JSON.stringify([identity.table.namespace, identity.table.name]));
+      }
+    }
+    lookups.independentTables = tables;
+  }
+  const placement = qualifiedSqlName({ name: target.dbName ?? target.name, namespace: target.namespace });
+  return !lookups.independentTables.has(JSON.stringify([placement.namespace, placement.name]));
+}
 function validateSchemaIR(params) {
   const { schema } = params;
   const issues = [];
@@ -1465,8 +1552,18 @@ function validateSchemaIR(params) {
       });
     }
   }
+  const fieldsByModel = new Map;
+  for (const model of schema.models) {
+    const fields = new Map;
+    for (const field of model.fields)
+      if (!fields.has(field.name))
+        fields.set(field.name, field);
+    fieldsByModel.set(model, fields);
+  }
+  const lookups = { fieldsByModel, partialKeys: new Map, totalKeys: new Map };
+  const postgres = providerToDialect({ provider: schema.datasource.provider }) === "postgres";
   for (const model of schema.models) {
-    validateModel({ model, modelByName, enumByName, issues });
+    validateModel({ model, modelByName, enumByName, issues, schema, lookups, postgres });
   }
   for (const model of schema.models) {
     for (const relation of model.relations) {
@@ -1511,19 +1608,11 @@ function validateSchemaIR(params) {
     }
   }
   for (const model of schema.models) {
-    const fieldNames = new Set(model.fields.map((field) => field.name));
-    const defaultKeys = new Set;
-    if (model.primaryKey !== undefined && model.primaryKey.fields.length > 1 && model.primaryKey.clientName === undefined) {
-      defaultKeys.add(model.primaryKey.fields.join("_"));
-    }
-    for (const index of model.indexes) {
-      if (index.kind === "unique" && index.where === undefined && index.fields.length > 1 && index.clientName === undefined) {
-        defaultKeys.add(index.fields.map((field) => field.name).join("_"));
-      }
-    }
-    const seenSelectorNames = new Set;
+    const fieldNames = fieldsByModel.get(model);
+    const seenSelectorNames = new Map;
+    const addressable = (names) => names.every((name) => fieldNames.get(name)?.isUnsupported !== true);
     const checkSelectorName = (params) => {
-      const { clientName, fieldCount, where, isUnique, site } = params;
+      const { clientName, fields, where, isUnique, site } = params;
       if (!isUnique) {
         issues.push({
           rule: "client-name-non-unique",
@@ -1540,7 +1629,7 @@ function validateSchemaIR(params) {
         });
         return;
       }
-      if (fieldCount < 2) {
+      if (fields.length < 2) {
         issues.push({
           rule: "client-name-single-field",
           message: `name: ("${clientName}") on a single-field ${site} of "${model.name}" \u2014 the field itself is the selector; name: applies to compound groups only`,
@@ -1548,7 +1637,9 @@ function validateSchemaIR(params) {
         });
         return;
       }
-      if (fieldNames.has(clientName) || defaultKeys.has(clientName) || seenSelectorNames.has(clientName)) {
+      const tuple = JSON.stringify(fields);
+      const previous = seenSelectorNames.get(clientName);
+      if (fieldNames.has(clientName) || previous !== undefined && previous !== tuple) {
         issues.push({
           rule: "client-name-collision",
           message: `name: ("${clientName}") on "${model.name}" collides with a field or another unique selector \u2014 WhereUniqueInput keys must be unambiguous`,
@@ -1556,22 +1647,22 @@ function validateSchemaIR(params) {
         });
         return;
       }
-      seenSelectorNames.add(clientName);
+      seenSelectorNames.set(clientName, tuple);
     };
-    if (model.primaryKey !== undefined && model.primaryKey.clientName !== undefined) {
+    if (model.primaryKey !== undefined && (model.primaryKey.clientName !== undefined || model.primaryKey.fields.length > 1 && addressable(model.primaryKey.fields))) {
       checkSelectorName({
-        clientName: model.primaryKey.clientName,
-        fieldCount: model.primaryKey.fields.length,
+        clientName: model.primaryKey.clientName ?? model.primaryKey.fields.join("_"),
+        fields: model.primaryKey.fields,
         isUnique: true,
         site: "@@id"
       });
     }
     for (const index of model.indexes) {
-      if (index.clientName === undefined)
+      if (index.clientName === undefined && (index.kind !== "unique" || index.where !== undefined || index.fields.length < 2 || !addressable(index.fields.map((field) => field.name))))
         continue;
       checkSelectorName({
-        clientName: index.clientName,
-        fieldCount: index.fields.length,
+        clientName: index.clientName ?? index.fields.map((field) => field.name).join("_"),
+        fields: index.fields.map((field) => field.name),
         ...index.where === undefined ? {} : { where: index.where },
         isUnique: index.kind === "unique",
         site: "@@unique"
@@ -1579,13 +1670,13 @@ function validateSchemaIR(params) {
     }
   }
   validateIdentifierLengths({ schema, issues });
-  validatePhysicalNameUniqueness({ schema, issues });
+  validatePhysicalNameUniqueness({ schema, issues, modelByName, fieldsByModel });
   validateGeneratedNames({ schema, issues });
   validateNativeRls({ schema, issues });
   return issues;
 }
 function validatePhysicalNameUniqueness(params) {
-  const { schema, issues } = params;
+  const { schema, issues, modelByName, fieldsByModel } = params;
   const dialect = providerToDialect({ provider: schema.datasource.provider });
   const owners = new Map;
   const claim = (entry) => {
@@ -1615,7 +1706,8 @@ function validatePhysicalNameUniqueness(params) {
     }
     if (model.isView)
       continue;
-    const columnOf = (name) => model.fields.find((candidate) => candidate.name === name)?.dbName ?? name;
+    const fields = fieldsByModel.get(model);
+    const columnOf = (name) => fields.get(name)?.dbName ?? name;
     const seenIndexKeys = new Set;
     const declarations = [
       ...model.indexes.map((index) => ({ index, site: index.kind === "unique" ? "@@unique" : "@@index" })),
@@ -1623,8 +1715,8 @@ function validatePhysicalNameUniqueness(params) {
     ];
     for (const { index, site } of declarations) {
       const unique = index.kind === "unique";
-      const columns = index.fields.map((entry) => `${columnOf(entry.name)}${entry.sort === "desc" ? " desc" : ""}`);
-      const key = `${unique ? "u" : "i"}${index.nullsNotDistinct === true ? "n" : ""}:${unique ? "btree" : index.kind}:${columns.join(",")}:${index.where?.trim() ?? ""}`;
+      const columns = index.fields.map((entry) => [columnOf(entry.name), entry.sort === "desc", entry.operatorClass === undefined ? null : [entry.operatorClass.namespace, entry.operatorClass.name]]);
+      const key = JSON.stringify([unique, index.nullsNotDistinct === true, unique ? "btree" : index.kind, columns, index.where?.trim() ?? ""]);
       if (seenIndexKeys.has(key))
         continue;
       seenIndexKeys.add(key);
@@ -1642,7 +1734,7 @@ function validatePhysicalNameUniqueness(params) {
     for (const relation of model.relations) {
       if (relation.fields === undefined || relation.fields.length === 0)
         continue;
-      const target = schema.models.find((candidate) => candidate.name === relation.targetModel);
+      const target = modelByName.get(relation.targetModel);
       if (target !== undefined && target.isView)
         continue;
       const name = relation.constraintName ?? defaultForeignKeyName({ table, columns: relation.fields.map((entry) => columnOf(entry)), dialect });
@@ -1671,7 +1763,7 @@ function validatePhysicalNameUniqueness(params) {
         continue;
       if (!isImplicitManyToManyRelation({ model, relation, models: schema.models }))
         continue;
-      const target = schema.models.find((candidate) => candidate.name === relation.targetModel);
+      const target = modelByName.get(relation.targetModel);
       const physicalNamespace = model.namespace ?? "public";
       if ((target?.namespace ?? "public") !== physicalNamespace) {
         issues.push({ rule: "implicit-join-namespace", message: "Implicit many-to-many endpoints must share one fixed namespace", model: model.name, field: relation.name });
@@ -1770,7 +1862,7 @@ function validateIdentifierLengths(params) {
   }
 }
 function validateModel(params) {
-  const { model, modelByName, enumByName, issues } = params;
+  const { model, modelByName, enumByName, issues, lookups, postgres } = params;
   const memberNames = new Set;
   for (const field of model.fields) {
     if (memberNames.has(field.name)) {
@@ -1872,8 +1964,23 @@ function validateModel(params) {
     }
     memberNames.add(relation.name);
   }
-  const fieldNames = new Set(model.fields.map((f) => f.name));
-  const hasIdField = model.fields.some((f) => f.isId);
+  const fieldNames = new Set(lookups.fieldsByModel.get(model).keys());
+  const idFields = model.fields.filter((f) => f.isId);
+  const hasIdField = idFields.length > 0;
+  if (idFields.length > 1) {
+    issues.push({
+      rule: "multiple-field-ids",
+      message: `Model "${model.name}" has multiple @id fields (${idFields.map((field) => field.name).join(", ")}); declare one compound primary key instead`,
+      model: model.name
+    });
+  }
+  if (idFields.length === 1 && model.primaryKey !== undefined && (model.primaryKey.fields.length !== 1 || model.primaryKey.fields[0] !== idFields[0]?.name)) {
+    issues.push({
+      rule: "conflicting-primary-key",
+      message: `Model "${model.name}" declares @id on "${idFields[0]?.name}" and a different block primary key; both declarations must name the same single logical field`,
+      model: model.name
+    });
+  }
   if (!model.isView && !hasIdField && model.primaryKey === undefined) {
     issues.push({
       rule: "missing-id",
@@ -1932,8 +2039,14 @@ function validateModel(params) {
           });
         }
       }
+      if (postgres && new Set(relation.references).size !== relation.references.length) {
+        issues.push({ rule: "relation-duplicate-column", message: `Relation "${model.name}.${relation.name}" repeats a referenced column`, model: model.name, field: relation.name });
+      }
       if (target !== undefined) {
-        const targetFieldNames = new Set(target.fields.map((f) => f.name));
+        if (postgres && referencesPartialOnly({ target, references: relation.references, schema: params.schema, lookups })) {
+          issues.push({ rule: "relation-partial-only-target", message: `Relation "${model.name}.${relation.name}" references only a partial unique key`, model: model.name, field: relation.name });
+        }
+        const targetFieldNames = lookups.fieldsByModel.get(target);
         for (const refField of relation.references) {
           if (!targetFieldNames.has(refField)) {
             issues.push({
@@ -2101,6 +2214,16 @@ function assertValidSchemaIR(params) {
     if (dialect === "mysql" && counters.length > 1)
       throw unsupportedCapability({ dialect, feature: "multiple auto-increment columns" });
     for (const field of model.fields) {
+      const timeOfDay = field.isUnsupported === true || field.type !== "DateTime" ? undefined : timeOfDayType({ nativeType: field.nativeType });
+      if (timeOfDay !== undefined && !DIALECT_CAPABILITIES[dialect].timeOfDayTypes.includes(timeOfDay)) {
+        const instead = dialect === "sqlite" ? "sqlite has no time-of-day column type; store a plain DateTime or a String" : "there is no time-with-offset type here; use @db.Time(n), which stores the UTC time of day";
+        const error = unsupportedCapability({ dialect, feature: "timeOfDayTypes", hint: `${model.name}.${field.name} declares @db.${field.nativeType ?? ""} (${timeOfDay}) \u2014 ${instead}` });
+        throw new VibeError({ code: error.code, message: error.message, meta: { ...error.meta, model: model.name, field: field.name, nativeType: field.nativeType } });
+      }
+      if (timeOfDay !== undefined && dialect === "mysql" && field.default?.kind === "now") {
+        const error = unsupportedCapability({ dialect, feature: "@default(now()) on a TIME column", hint: `${model.name}.${field.name} \u2014 MySQL has no current-time default for TIME; drop the default and write the value (or use @updatedAt)` });
+        throw new VibeError({ code: error.code, message: error.message, meta: { ...error.meta, model: model.name, field: field.name, nativeType: field.nativeType } });
+      }
       if (field.default?.kind === "list") {
         if (dialect !== "postgres")
           throw unsupportedCapability({ dialect, feature: "scalar-list defaults" });
@@ -2376,10 +2499,11 @@ export {
   sqlNamespaceIssue,
   sqlObjectKey,
   sqlObjectNamespace,
+  timeOfDayType,
   unsupportedCapability,
   validateComputedConfig,
   validateRlsContextIR,
   validateSchemaIR
 };
 
-//# debugId=20984641ACA6D36E64756E2164756E21
+//# debugId=99BBBD6C3E58D9DD64756E2164756E21