uql-orm 0.61.0 → 0.63.0

package/dist/util/dialect.util.js

@@ -222,7 +222,7 @@ export function hasVectorNear(where) {
     return Object.entries(where).some(([key, value]) => key === '$near' || hasVectorNear(value));
 }
 function indexCoversColumn(index, key) {
-    return index.columns.some((entry) => !(entry instanceof QueryRaw) && entry.column === key);
+    return index.columns.some((entry) => entry.column === key);
 }
 /** `satisfies` ties this to {@link JsonUpdateOp}, so renaming an operator breaks it at compile time. */
 const JSON_UPDATE_OPS = [
@@ -293,8 +293,7 @@ export function applyFilters(meta, whereMap, opts) {
         if (!active) {
             continue;
         }
-        const raw = filter.condition;
-        const condition = typeof raw === 'function' ? raw(context) : raw;
+        const condition = typeof filter.where === 'function' ? filter.where(context) : filter.where;
         if (condition === undefined) {
             const onMissing = filter.onMissing ?? (filter.security ? 'throw' : 'skip');
             if (onMissing === 'throw') {
@@ -444,7 +443,7 @@ export function textSearchFields(meta, search) {
     }
     const fulltext = (meta.indexes ?? []).filter((index) => index.type === 'fulltext');
     if (fulltext.length === 1) {
-        return fulltext[0].columns.map((entry) => entry.column);
+        return fulltext[0].columns.flatMap((entry) => (typeof entry.column === 'string' ? [entry.column] : []));
     }
     const name = entityName(meta);
     const declared = fulltext.length

package/dist/util/field.util.d.ts

@@ -32,7 +32,7 @@ export declare function isIntegerColumn(field: Pick<FieldOptions, 'type' | 'colu
  * Every read site asks this - the DDL skip, the projection, the `$where` and `ORDER BY` operands -
  * because an inlined field has no column to name, while a stored one is read like any other.
  */
-export declare function isInlinedExpression(field: FieldOptions): boolean;
+export declare function isInlinedExpression<F extends FieldOptions>(field: F): field is F & Required<Pick<F, 'computed'>>;
 /**
  * Whether the database supplies this field's value, so no insert or update may write it: a stored
  * computed column *is* a real column, read like one, but writing to it is an error on every engine.

package/dist/util/raw.d.ts

@@ -1,36 +1,43 @@
-import { QueryRaw, type QueryRawFn } from '../type/index.js';
+import { type EntitySql, type EntityWhere, type EntityWhereMeta, QueryRaw, type QueryRawFn, type RefMap, type Type } from '../type/index.js';
 /**
  * Create a raw SQL expression.
  *
  * As a tagged template the literal text is emitted as written and every interpolation is resolved by
  * what it is, so a value cannot become SQL whatever it holds:
  *
- * | Interpolated       | Becomes                 |
- * | :----------------- | :---------------------- |
- * | any value          | a bound parameter       |
- * | a {@link QueryRaw} | that fragment, in place |
+ * | Interpolated        | Becomes                                |
+ * | :------------------ | :------------------------------------- |
+ * | any value           | a bound parameter; in DDL, its literal |
+ * | a {@link ColumnRef} | its column, escaped and qualified      |
+ * | a {@link QueryRaw}  | that fragment, in place                |
  *
  * ```ts
- * raw`GREATEST(0, "creditsAllowance" - ${amount})`
- * raw`CONCAT(${col('firstName')}, ' ', ${col('lastName')})`
+ * const user = refs(User);
+ * raw`GREATEST(0, ${user.creditsAllowance} - ${amount})`
+ * raw`CONCAT(${user.firstName}, ' ', ${user.lastName})`
  * raw`LOG10(${points})`.as('score')
  * ```
  *
  * The callback form remains for SQL a template cannot express, such as a sub-query generated through
- * `dialect.find(...)`. See {@link col} for a context-aware column reference.
+ * `dialect.find(...)`.
  *
  * **⚠️ Security:** the tag is safe because it binds; a callback is not, since it emits whatever it
  * writes, so never build one from user input. Inside a callback, bind with `ctx.addValue()`.
  */
 export declare function raw(strings: TemplateStringsArray, ...values: readonly unknown[]): QueryRaw;
-export declare function raw(value: QueryRawFn, alias?: string): QueryRaw;
+export declare function raw(value: QueryRawFn): QueryRaw;
 /**
- * A column of the entity being queried, alias-qualified and escaped for the dialect. This is what a
- * template cannot know on its own: the alias is decided while the statement is built, not where the
- * expression is written.
- *
- * Takes the column name as it exists in the database, not the entity's field name: no entity metadata
- * is in scope here, so a naming strategy is not applied for you. `escapedPrefix` already carries its
- * trailing dot, which is the detail this exists to stop you getting wrong.
+ * The fields of `entity` as {@link ColumnRef}s, each rendering inside `raw` as its column: named the way
+ * the dialect names it, so the naming strategy and `@Field({ name })` apply, and qualified by the alias
+ * in scope. Metadata is read when a ref renders, so the map serves before the fields are registered.
+ */
+export declare function refs<E>(entity: Type<E>): RefMap<E>;
+/**
+ * The refs a definition's callbacks read: an index's, a check's, a computed field's. A member decorator
+ * sees no class, so these name no entity and resolve against the one rendering them.
  */
-export declare function col(column: string): QueryRaw;
+export declare function memberRefs<E>(): RefMap<E>;
+/** SQL a definition writes, a callback's refs read off {@link memberRefs}. */
+export declare function entitySql<E>(sql: EntitySql<E>): QueryRaw;
+/** A definition's predicate, its callback resolved the way {@link entitySql} resolves one. */
+export declare function entityWhere<E>(where: EntityWhere<E>): EntityWhereMeta<E>;

package/dist/util/raw.js

@@ -1,13 +1,9 @@
-import { QueryRaw } from '../type/index.js';
+import { getMeta } from '../entity/metadata/definition.js';
+import { ColumnRef, QueryRaw, } from '../type/index.js';
+import { isInlinedExpression } from './field.util.js';
 export function raw(value, ...rest) {
-    const [alias] = rest;
     if (!isTemplateStrings(value)) {
-        return new QueryRaw(value, typeof alias === 'string' ? alias : undefined);
-    }
-    if (!rest.length) {
-        // Nothing to bind, so this is the string form: keep it one, for the DDL paths that need to read
-        // the expression back as text (an index expression cannot carry a parameter).
-        return new QueryRaw(value[0]);
+        return new QueryRaw(value);
     }
     return new QueryRaw((opts) => {
         const { ctx } = opts;
@@ -24,16 +20,49 @@ export function raw(value, ...rest) {
     });
 }
 /**
- * A column of the entity being queried, alias-qualified and escaped for the dialect. This is what a
- * template cannot know on its own: the alias is decided while the statement is built, not where the
- * expression is written.
- *
- * Takes the column name as it exists in the database, not the entity's field name: no entity metadata
- * is in scope here, so a naming strategy is not applied for you. `escapedPrefix` already carries its
- * trailing dot, which is the detail this exists to stop you getting wrong.
+ * The fields of `entity` as {@link ColumnRef}s, each rendering inside `raw` as its column: named the way
+ * the dialect names it, so the naming strategy and `@Field({ name })` apply, and qualified by the alias
+ * in scope. Metadata is read when a ref renders, so the map serves before the fields are registered.
  */
-export function col(column) {
-    return new QueryRaw(({ escapedPrefix, dialect }) => escapedPrefix + dialect.escapeId(column, true));
+export function refs(entity) {
+    return new Proxy({}, { get: (_, key) => columnRef(entity, String(key)) });
+}
+const MEMBER_REFS = new Proxy({}, { get: (_, key) => columnRef(undefined, String(key)) });
+/**
+ * The refs a definition's callbacks read: an index's, a check's, a computed field's. A member decorator
+ * sees no class, so these name no entity and resolve against the one rendering them.
+ */
+export function memberRefs() {
+    return MEMBER_REFS;
+}
+/** SQL a definition writes, a callback's refs read off {@link memberRefs}. */
+export function entitySql(sql) {
+    return sql instanceof QueryRaw ? sql : sql(memberRefs());
+}
+/** A definition's predicate, its callback resolved the way {@link entitySql} resolves one. */
+export function entityWhere(where) {
+    return typeof where === 'function' ? where(memberRefs()) : where;
+}
+/** One field as SQL, against its own entity or, read off a definition, the entity rendering it. */
+function columnRef(entity, key) {
+    return new ColumnRef(key, (opts) => {
+        const owner = entity ?? opts.entity;
+        if (!owner) {
+            throw new TypeError(`'${key}' was read off a definition's refs, so it renders only inside its entity's SQL`);
+        }
+        renderColumn(getMeta(owner), key, { ...opts, entity: owner });
+    });
+}
+/** A field's column, or the expression an inlined computed one stands for, as a `$where` on it reads it. */
+function renderColumn(meta, key, opts) {
+    const field = meta.fields[key];
+    if (field && isInlinedExpression(field)) {
+        opts.ctx.append('(');
+        field.computed.render(opts);
+        opts.ctx.append(')');
+        return;
+    }
+    opts.ctx.append(opts.escapedPrefix + opts.dialect.escapeId(opts.dialect.columnOf(meta, key), true));
 }
 /** A tag call passes the frozen strings array, which carries its own `raw` counterpart. */
 function isTemplateStrings(value) {

package/dist/util/wideNumber.d.ts

@@ -8,7 +8,7 @@ import type { RawRow } from '../type/index.js';
 export declare function decodeWideNumber(value: string | bigint): number | string;
 /**
  * {@link decodeWideNumber} over every `bigint` cell of a row, for the drivers that hand a BIGINT back
- * as one (`bun:sql` with `bigint: true`, `mariadb`). In place: the row is the driver's fresh object, and
- * a copy per row cost more than the decode it carried.
+ * as one (`bun:sql`, `mariadb`, and every SQLite driver but D1). In place: the row is the driver's fresh
+ * object, and a copy per row cost more than the decode it carried.
  */
 export declare function decodeBigInts(row: RawRow): RawRow;

package/dist/util/wideNumber.js

@@ -10,8 +10,8 @@ export function decodeWideNumber(value) {
 }
 /**
  * {@link decodeWideNumber} over every `bigint` cell of a row, for the drivers that hand a BIGINT back
- * as one (`bun:sql` with `bigint: true`, `mariadb`). In place: the row is the driver's fresh object, and
- * a copy per row cost more than the decode it carried.
+ * as one (`bun:sql`, `mariadb`, and every SQLite driver but D1). In place: the row is the driver's fresh
+ * object, and a copy per row cost more than the decode it carried.
  */
 export function decodeBigInts(row) {
     for (const key in row) {

package/package.json

@@ -3,7 +3,7 @@
   "homepage": "https://uql-orm.dev",
   "description": "The JSON-native TypeScript ORM for Bun, Browsers, Edge, Deno, Node, Workers. Supports PostgreSQL, PGlite, MySQL, MariaDB, SQLite, CockroachDB, SQL Server, Turso, Neon, Cloudflare D1 and MongoDB. Queries are plain JSON, typed to the leaf.",
   "license": "MIT",
-  "version": "0.61.0",
+  "version": "0.63.0",
   "type": "module",
   "engines": {
     "node": ">=24"
@@ -71,7 +71,7 @@
     "@nestjs/common": ">=10.0.0",
     "@nestjs/core": ">=10.0.0",
     "@tursodatabase/database": ">=0.7.0",
-    "@tursodatabase/serverless": ">=1.0.0",
+    "@tursodatabase/serverless": ">=1.3.0",
     "better-sqlite3": ">=9.0.0",
     "express": ">=5.0.0",
     "mariadb": ">=3.0.0",

package/dist/sqlite/hranaQuerierPool.d.ts

@@ -1,20 +0,0 @@
-import { AbstractSqlQuerierPool } from '../querier/index.js';
-import { type HranaClient, HranaQuerier } from './hranaQuerier.js';
-import type { SqliteDialect } from './sqliteDialect.js';
-/**
- * Pool for SQLite databases reached over the Hrana wire protocol (`@libsql/client`,
- * `@tursodatabase/serverless/compat`).
- *
- * @remarks The client is shared by every querier, since Hrana keeps no per-connection state: a
- * transaction takes its own session handle. It is resolved on first use rather than in the
- * constructor, so building a pool never throws when the optional driver peer is absent, which is what
- * lets a Workers bundle construct one at module scope.
- */
-export declare abstract class AbstractHranaQuerierPool<D extends SqliteDialect> extends AbstractSqlQuerierPool<HranaQuerier, D> {
-    private client?;
-    /** False when the caller injected their own client, in which case they own its lifecycle. */
-    protected readonly ownsClient: boolean;
-    protected abstract openClient(): Promise<HranaClient>;
-    getQuerier(): Promise<HranaQuerier>;
-    end(): Promise<void>;
-}

package/dist/sqlite/hranaQuerierPool.js

@@ -1,26 +0,0 @@
-import { AbstractSqlQuerierPool } from '../querier/index.js';
-import { HranaQuerier } from './hranaQuerier.js';
-/**
- * Pool for SQLite databases reached over the Hrana wire protocol (`@libsql/client`,
- * `@tursodatabase/serverless/compat`).
- *
- * @remarks The client is shared by every querier, since Hrana keeps no per-connection state: a
- * transaction takes its own session handle. It is resolved on first use rather than in the
- * constructor, so building a pool never throws when the optional driver peer is absent, which is what
- * lets a Workers bundle construct one at module scope.
- */
-export class AbstractHranaQuerierPool extends AbstractSqlQuerierPool {
-    client;
-    /** False when the caller injected their own client, in which case they own its lifecycle. */
-    ownsClient = true;
-    async getQuerier() {
-        this.client ??= await this.openClient();
-        return new HranaQuerier(this.client, this.dialect, this.extra);
-    }
-    async end() {
-        if (this.ownsClient) {
-            this.client?.close();
-        }
-        this.client = undefined;
-    }
-}

package/dist/turso/tursoLocalQuerier.d.ts

@@ -1,24 +0,0 @@
-import { PreparedSqliteQuerier, type SqlitePreparedStatement } from '../sqlite/abstractSqliteQuerier.js';
-import type { SqliteDialect } from '../sqlite/sqliteDialect.js';
-import type { ExtraOptions } from '../type/index.js';
-/**
- * Structural subset of the `@tursodatabase/database` API actually used here, declared locally so
- * this package does not couple its published types to a pre-1.0 dependency.
- */
-export type TursoDatabase = {
-    prepare(sql: string): Promise<SqlitePreparedStatement>;
-    close(): Promise<void>;
-};
-/**
- * Querier for the embedded Turso engine.
- *
- * @remarks The engine exposes better-sqlite3 semantics (`reader`, `{changes, lastInsertRowid}`,
- * array-bound values) over an async API, so all it supplies is the awaited `prepare`.
- * `BEGIN`/`COMMIT` work as plain statements, leaving transactions to the base class.
- */
-export declare class TursoLocalQuerier extends PreparedSqliteQuerier {
-    readonly db: TursoDatabase;
-    readonly extra?: ExtraOptions | undefined;
-    constructor(db: TursoDatabase, dialect: SqliteDialect, extra?: ExtraOptions | undefined);
-    protected prepare(query: string): Promise<SqlitePreparedStatement>;
-}

package/dist/turso/tursoLocalQuerier.js

@@ -1,20 +0,0 @@
-import { PreparedSqliteQuerier } from '../sqlite/abstractSqliteQuerier.js';
-/**
- * Querier for the embedded Turso engine.
- *
- * @remarks The engine exposes better-sqlite3 semantics (`reader`, `{changes, lastInsertRowid}`,
- * array-bound values) over an async API, so all it supplies is the awaited `prepare`.
- * `BEGIN`/`COMMIT` work as plain statements, leaving transactions to the base class.
- */
-export class TursoLocalQuerier extends PreparedSqliteQuerier {
-    db;
-    extra;
-    constructor(db, dialect, extra) {
-        super(dialect, extra);
-        this.db = db;
-        this.extra = extra;
-    }
-    prepare(query) {
-        return this.db.prepare(query);
-    }
-}