@vibeorm/sql 5.1.0 → 5.2.0

package/dist/ast.d.ts

@@ -45,6 +45,8 @@ export type ColRef = {
      * storage and read-back stay the exact text.
      */
     readonly castReal?: boolean;
+    /** Native enum order key through a scalar subquery: MySQL reads its member index, other dialects keep the column. */
+    readonly enumOrdinal?: true;
     /**
      * Order/distinct/compare cast, postgres `json` columns only (`Json @db.Json`,
      * release-3.0 D3): `json` has no ordering or equality operator, so ORDER BY,
@@ -93,6 +95,8 @@ export type AggRef = {
 } | {
     readonly fn: AggFn;
     readonly column: ColRef;
+    /** Native enum MIN/MAX: projections and HAVING return the database label; order keys keep its ordinal. */
+    readonly enumOrder?: "value" | "ordinal";
 };
 /**
  * One aggregate projection: `FN("col") AS "alias"`. The alias is part of the
@@ -463,18 +467,27 @@ export type OrderByAggregate = {
 };
 /**
  * ORDER BY a correlated scalar subquery — relation orderBy
- * (`orderBy: { posts: { _count: "desc" } }` → `(SELECT COUNT(*) …)` /
+ * (`orderBy: { posts: { _count: "desc" } }` → `(SELECT COUNT(*) …)`,
+ * `orderBy: { posts: { _max: { createdAt: "desc" } } }` → `(SELECT MAX(…) …)`,
  * `orderBy: { author: { email: "asc" } }` → `(SELECT "email" …)`).
  * Portable: all three dialects order by scalar subqueries. The subquery
  * correlates to the outer scope through table-qualified `cmpCol` predicates,
  * exactly like `exists`; its parameters merge into the statement's single
- * sequence in render order. NULLS placement is deliberately unsupported here
- * (emulating it would render the subquery twice and duplicate its params) —
- * missing relations sort at each engine's native NULL position.
+ * sequence in render order.
+ *
+ * `nulls` places the NULL a missing to-one row or a parent without related
+ * rows (under MIN/MAX/AVG/SUM) sorts as. Without it, NULL sorts at the
+ * engine's native position. Postgres and sqlite render `NULLS FIRST|LAST`;
+ * mysql renders the bare term when its native placement already matches, and
+ * otherwise a leading `(<subquery>) IS NULL` term — the subquery then renders
+ * twice and its parameters bind twice, in text order.
  */
 export type OrderBySubquery = {
     readonly select: SelectStatement;
+    /** A count behind a missing to-one row is zero, not NULL. */
+    readonly coalesce?: 0;
     readonly direction: "asc" | "desc";
+    readonly nulls?: "first" | "last";
 };
 export type OrderTerm = OrderByColumn | OrderByAggregate | OrderBySubquery;
 /**
@@ -519,6 +532,17 @@ export type LateralJoin = {
     /** The correlated child select — may reference outer columns via table-qualified refs. */
     readonly select: SelectStatement;
 };
+/**
+ * One scalar subquery in a projection. The builder guarantees a single column
+ * and at most one row. Hidden sort values stay inside derived tables rather
+ * than becoming result fields. `coalesce` preserves a count across a missing
+ * to-one hop.
+ */
+export type ScalarSubquery = {
+    readonly alias: string;
+    readonly select: SelectStatement;
+    readonly coalesce?: 0;
+};
 /**
  * One correlated scalar `COUNT(*)` projected into a select list:
  * `(SELECT COUNT(*) FROM … WHERE <correlation>) AS "alias"` — the relation
@@ -765,6 +789,8 @@ export type SelectStatement = {
     readonly aggregates?: readonly AggSelect[];
     /** Correlated `COUNT(*)` subqueries, rendered after `aggregates` — see {@link CountSubquery}. */
     readonly countSubqueries?: readonly CountSubquery[];
+    /** Scalar values projected after count subqueries and before a row number. */
+    readonly scalarSubqueries?: readonly ScalarSubquery[];
     /**
      * `SELECT DISTINCT ON (cols)` — postgres only (`capabilities.distinctOn`;
      * other dialects refuse at render time and the runtime emulates client-side

package/dist/dialect.d.ts

@@ -446,6 +446,16 @@ export type SqlDialect = {
     quoteStringLiteral(params: {
         value: string;
     }): string;
+    /** Keep a native enum's ordering through a scalar subquery that may lose its physical enum type. */
+    renderEnumOrdinal(params: {
+        column: string;
+    }): string;
+    /** Render native enum MIN/MAX in database declaration order, returning its label or an order key. */
+    renderEnumMinMax(params: {
+        fn: "min" | "max";
+        column: string;
+        result: "value" | "ordinal";
+    }): string;
     /** Positional placeholder for the 1-based parameter index ($n or ?). */
     placeholder(params: {
         index: number;

package/dist/index.d.ts

@@ -40,7 +40,7 @@ export type { ResultDecoder, ResultReadDecoder, ResultParameterEncoder, ResultSc
  * lives in this package; see the root sql-catalog.md for the reviewable surface.
  */
 export { compileExclusion, renderExclusionSetup, renderExclusionDdl, renderExclusionCatalog, renderExclusionProbe } from "./exclusion.ts";
-export type { AdvisoryLockKey, AdvisoryLockStatement, AggFn, AggRef, AggSelect, ChainResult, ChainRowSource, ChainStatement, ChainStep, ChainStepStatement, ChainTally, ChainVeto, ColRef, ComparisonOp, DateTruncation, CountSubquery, DeleteStatement, ExcludedRef, InnerJoin, KeyListMember, KeyPage, KeyRows, KeyTableJoin, KeyTableMember, InsertSelectStatement, InsertStatement, ReturningColumn, JsonFilterOp, LateralJoin, LeftJoin, ListSetOperation, OnConflictClause, OnConflictDoNothing, OnConflictUpdate, OrderByAggregate, OrderByColumn, OrderBySubquery, OrderTerm, RowLock, RowNumberProjection, DbNowMarker, JsonParamCell, SelectExpr, SelectStatement, SetOperation, SetOperator, SqlExpr, SqlStatement, StepColumnRef, TableRef, UpdateStatement, } from "./ast.ts";
+export type { AdvisoryLockKey, AdvisoryLockStatement, AggFn, AggRef, AggSelect, ChainResult, ChainRowSource, ChainStatement, ChainStep, ChainStepStatement, ChainTally, ChainVeto, ColRef, ComparisonOp, DateTruncation, CountSubquery, ScalarSubquery, DeleteStatement, ExcludedRef, InnerJoin, KeyListMember, KeyPage, KeyRows, KeyTableJoin, KeyTableMember, InsertSelectStatement, InsertStatement, ReturningColumn, JsonFilterOp, LateralJoin, LeftJoin, ListSetOperation, OnConflictClause, OnConflictDoNothing, OnConflictUpdate, OrderByAggregate, OrderByColumn, OrderBySubquery, OrderTerm, RowLock, RowNumberProjection, DbNowMarker, JsonParamCell, SelectExpr, SelectStatement, SetOperation, SetOperator, SqlExpr, SqlStatement, StepColumnRef, TableRef, UpdateStatement, } from "./ast.ts";
 export { ADVISORY_LOCK_RESULT_COLUMN, CHAIN_VETO_PREFIX, CHAIN_VETO_TOKEN_PATTERN, SQL_DEFAULT_CELL, SQL_KEEP_CELL, chainVetoToken, dbNowMarker, excludedRef, isDbNowMarker, isExcludedRef, isJsonParamCell, isListSetOperation, isSetOperation, isSqlDefaultCell, isSqlKeepCell, isStepColumnRef, jsonParamCell, returningColumnName, stepColumnRef, } from "./ast.ts";
 export type { AdvisoryLockFunctions, AdvisoryLockModeFunctions, RowLockSyntax, EmptyInsertSyntax, SqlDialect, } from "./dialect.ts";
 export { ADVISORY_KEY_BOUNDS, describeRowLock, renderAdvisoryLock, renderRowLockClause } from "./locks.ts";

package/dist/index.js

@@ -2402,6 +2402,12 @@ var sqliteDialect = {
   quoteStringLiteral({ value }) {
     return `'${value.replaceAll("'", "''")}'`;
   },
+  renderEnumOrdinal({ column }) {
+    return column;
+  },
+  renderEnumMinMax({ fn, column }) {
+    return `${fn === "min" ? "MIN" : "MAX"}(${column})`;
+  },
   placeholder() {
     return "?";
   },
@@ -3075,6 +3081,12 @@ var postgresDialect = {
   quoteStringLiteral({ value }) {
     return `'${value.replaceAll("'", "''")}'`;
   },
+  renderEnumOrdinal({ column }) {
+    return column;
+  },
+  renderEnumMinMax({ fn, column }) {
+    return `${fn === "min" ? "MIN" : "MAX"}(${column})`;
+  },
   placeholder({ index }) {
     return `$${index}`;
   },
@@ -3148,6 +3160,15 @@ var mysqlDialect = {
   quoteStringLiteral({ value }) {
     return `'${value.replaceAll("\\", "\\\\").replaceAll("'", "''")}'`;
   },
+  renderEnumOrdinal({ column }) {
+    return `${column} + 0`;
+  },
+  renderEnumMinMax({ fn, column, result }) {
+    const aggregate = fn === "min" ? "MIN" : "MAX";
+    if (result === "ordinal")
+      return `${aggregate}(${column} + 0)`;
+    return `SUBSTRING(${aggregate}(CONCAT(LPAD(${column} + 0, 5, '0'), ${column})), 6)`;
+  },
   placeholder() {
     return "?";
   },
@@ -4129,6 +4150,8 @@ function quoteCol(dialect, column) {
   const ref = column.table === undefined ? name : `${dialect.quoteIdent({ name: column.table })}.${name}`;
   if (column.truncate !== undefined)
     return renderDateTruncation({ dialect, reference: ref, truncation: column.truncate });
+  if (column.enumOrdinal === true)
+    return dialect.renderEnumOrdinal({ column: ref });
   if (column.castReal === true) {
     if (dialect.name !== "sqlite") {
       throw internalError4({ message: "ColRef.castReal is a sqlite Decimal construct" });
@@ -4229,7 +4252,11 @@ var AGG_FN_SQL = {
 function renderAggRef(dialect, agg) {
   if (agg.fn === "countAll")
     return "COUNT(*)";
-  return `${AGG_FN_SQL[agg.fn]}(${quoteCol(dialect, agg.column)})`;
+  const column = quoteCol(dialect, agg.column);
+  if ((agg.fn === "min" || agg.fn === "max") && agg.enumOrder !== undefined) {
+    return dialect.renderEnumMinMax({ fn: agg.fn, column, result: agg.enumOrder });
+  }
+  return `${AGG_FN_SQL[agg.fn]}(${column})`;
 }
 function assertScalarArrays(dialect, feature) {
   if (dialect.capabilities.scalarArrays)
@@ -4770,23 +4797,20 @@ function renderOrderTerm(params) {
   if ("agg" in term) {
     return `${renderAggRef(dialect, term.agg)} ${term.direction === "asc" ? "ASC" : "DESC"}`;
   }
-  if ("select" in term) {
-    const sub = renderSelect({ dialect, statement: term.select, collector });
-    return `(${sub.text}) ${term.direction === "asc" ? "ASC" : "DESC"}`;
-  }
-  const column = quoteCol(dialect, term.column);
+  const expression = "select" in term ? () => renderScalarSubquery({ dialect, subquery: term, collector }) : () => quoteCol(dialect, term.column);
   const direction = term.direction === "asc" ? "ASC" : "DESC";
   if (term.nulls === undefined) {
-    return `${column} ${direction}`;
+    return `${expression()} ${direction}`;
   }
   if (dialect.orderByNullsMode === "native") {
-    return `${column} ${direction} NULLS ${term.nulls === "first" ? "FIRST" : "LAST"}`;
+    return `${expression()} ${direction} NULLS ${term.nulls === "first" ? "FIRST" : "LAST"}`;
   }
   if (term.nulls === "first" === (term.direction === "asc")) {
-    return `${column} ${direction}`;
+    return `${expression()} ${direction}`;
   }
-  const nullsTerm = term.nulls === "first" ? `${column} IS NULL DESC` : `${column} IS NULL`;
-  return `${nullsTerm}, ${column} ${direction}`;
+  const tested = expression();
+  const nullsTerm = term.nulls === "first" ? `${tested} IS NULL DESC` : `${tested} IS NULL`;
+  return `${nullsTerm}, ${expression()} ${direction}`;
 }
 function renderSelectExpr(params) {
   const { dialect, expr } = params;
@@ -4837,7 +4861,7 @@ function renderLateralJoin(params) {
   const json = lateralJsonOf({ dialect });
   let aggOrder = "";
   if (json.order === "inAggregate" && join.agg === "jsonArray" && join.select.orderBy !== undefined && join.select.orderBy.length > 0) {
-    const projected = new Set(join.select.columns.filter((column) => column.transform === undefined && column.castReal !== true).map((column) => column.name));
+    const projected = new Set(join.select.columns.filter((column) => column.transform === undefined && column.castReal !== true).map((column) => column.name).concat((join.select.scalarSubqueries ?? []).map((subquery) => subquery.alias)));
     const terms = join.select.orderBy;
     const columnTerms = terms.filter((term) => ("column" in term));
     if (columnTerms.length === terms.length && columnTerms.every((term) => projected.has(term.column.name))) {
@@ -4863,12 +4887,17 @@ function renderLateralJoin(params) {
 function renderCountSubquery(params) {
   const { dialect, subquery, collector } = params;
   const select = subquery.select;
-  if (select.columns.length !== 0 || select.selectExpr?.kind !== "countAll" || (select.aggregates?.length ?? 0) > 0 || select.rowNumber !== undefined || select.groupBy !== undefined || select.having !== undefined || select.limit !== undefined || select.offset !== undefined || select.distinctOn !== undefined || select.distinct !== undefined || select.rowLock !== undefined || select.countSubqueries !== undefined) {
+  if (select.columns.length !== 0 || select.selectExpr?.kind !== "countAll" || (select.aggregates?.length ?? 0) > 0 || select.rowNumber !== undefined || select.groupBy !== undefined || select.having !== undefined || select.limit !== undefined || select.offset !== undefined || select.distinctOn !== undefined || select.distinct !== undefined || select.rowLock !== undefined || select.countSubqueries !== undefined || select.scalarSubqueries !== undefined) {
     throw internalError4({ message: "count subquery must be one ungrouped COUNT(*)" });
   }
   const inner = renderSelect({ dialect, statement: select, collector });
   return `(${inner.text}) AS ${dialect.quoteIdent({ name: subquery.alias })}`;
 }
+function renderScalarSubquery(params) {
+  const { dialect, subquery, collector } = params;
+  const value = `(${renderSelect({ dialect, statement: subquery.select, collector }).text})`;
+  return subquery.coalesce === 0 ? `COALESCE(${value}, 0)` : value;
+}
 function applyReturning(params) {
   const { dialect, requested } = params;
   if (requested === undefined || requested.length === 0) {
@@ -4977,6 +5006,11 @@ function renderSelect(params) {
       columnList.push(renderCountSubquery({ dialect, subquery, collector }));
     }
   }
+  if (statement.scalarSubqueries !== undefined) {
+    for (const subquery of statement.scalarSubqueries) {
+      columnList.push(`${renderScalarSubquery({ dialect, subquery, collector })} AS ${dialect.quoteIdent({ name: subquery.alias })}`);
+    }
+  }
   if (statement.rowNumber !== undefined) {
     const rowNumber = statement.rowNumber;
     if (rowNumber.partitionBy.length === 0 && rowNumber.orderBy.length === 0) {
@@ -6380,4 +6414,4 @@ export {
   toPgArrayLiteral
 };
 
-//# debugId=DB7441716F57EC8864756E2164756E21
+//# debugId=7A09C0BE2E07A46664756E2164756E21