uql-orm 0.33.0 → 0.34.1

package/dist/type/entity.d.ts

@@ -577,6 +577,8 @@ export type EntityIndexMeta = {
 export type EntityMeta<E> = {
     readonly entity: Type<E>;
     name?: string;
+    /** Set only when the entity named one; unset defers to the pool where it is used. See `AbstractDialect.resolveSchema`. */
+    schema?: string;
     id: IdKey<E>;
     softDelete?: FieldKey<E>;
     /** Named, default-on `$where` filters applied to every query unless bypassed. */
@@ -605,6 +607,11 @@ export type EntityMeta<E> = {
  */
 export type EntityOptions<E = unknown> = {
     readonly name?: string;
+    /**
+     * The schema (in MySQL terms, database) this table lives in, pinning it whichever pool reads it;
+     * unset follows the pool's own. Not in `name`: a dotted `name` is rejected.
+     */
+    readonly schema?: string;
     /** Named, default-on `$where` filters (soft-delete is auto-registered from `@Field({ softDelete })`). */
     readonly filters?: Record<string, FilterOptions<E>>;
     /** Scalar fields; use `isId: true` on exactly one field for the primary key. */

package/dist/type/migration.d.ts

@@ -168,7 +168,13 @@ export interface ForeignKeySchema {
  * Represents a difference between current and desired schema
  */
 export interface SchemaDiff {
+    /** Qualified where the table has a schema, since it is also the key the table is found under. */
     readonly tableName: string;
+    /**
+     * The schema {@link tableName} is in, carried separately for the identifiers that live in it
+     * rather than name it: a Postgres index is dropped as `schema.index`, never `schema.table`.
+     */
+    readonly schema?: string;
     readonly type: 'create' | 'alter' | 'drop';
     readonly columnsToAdd?: ColumnSchema[];
     readonly columnsToAlter?: {
@@ -243,9 +249,17 @@ export interface SchemaGenerator {
      */
     diffSchema<E>(entity: Type<E>, currentTable: TableNode | undefined): SchemaDiff | undefined;
     /**
-     * Resolve table name using entity and naming strategy
+     * The table's key: {@link resolveTableAlias} behind {@link resolveSchema}, which is how a
+     * `SchemaAST` stores it and how a diff finds it again.
+     */
+    resolveTableName<E>(meta: EntityMeta<E>): string;
+    /**
+     * The table's own name, unqualified. What a derived index or constraint name is built from, since
+     * those are single identifiers.
      */
-    resolveTableName<E>(entity: Type<E>, meta: EntityMeta<E>): string;
+    resolveTableAlias<E>(meta: EntityMeta<E>): string;
+    /** The schema the table lives in, `undefined` where nothing named one. */
+    resolveSchema<E>(meta: EntityMeta<E>): string | undefined;
     /**
      * Resolve column name using field options and naming strategy
      */

package/dist/type/querier.d.ts

@@ -164,5 +164,10 @@ export type ExtraOptions = {
     /** Threshold in milliseconds - queries exceeding this are logged as slow. */
     readonly slowQuery?: number;
     readonly namingStrategy?: NamingStrategy;
+    /**
+     * Default schema (in MySQL terms, database) for entities naming none; unset leaves them
+     * unqualified. `@Entity({ schema })` overrides it.
+     */
+    readonly schema?: string;
     readonly listeners?: readonly QuerierListener[];
 };

package/dist/util/sql.util.d.ts

@@ -9,6 +9,23 @@ export declare function unflatObject<T extends object>(row: RawRow, attrsPaths:
 export declare function obtainAttrsPaths<T extends object>(row: T): {
     [k: string]: string[];
 };
+/**
+ * A name behind its namespace, or bare where there is none: the one place the two are joined, so a
+ * table's key, its statement operand and its escaped form cannot spell it differently. Never the
+ * seed for a derived identifier - an index or constraint name is a single identifier, and
+ * `idx_sales.Order_total` is a syntax error.
+ */
+export declare function qualifyName(name: string, schema?: string): string;
+/**
+ * The name a derived index or constraint gets when nothing named it: `idx_Order_total`.
+ *
+ * One owner, because it is a rule two layers apply and a third has to match: the entity AST derives
+ * it, the DDL generator falls back to it, and a diff compares what the database reports against it.
+ * `table` is the table's own name, never qualified - the result is a single identifier.
+ */
+export declare function derivedIndexName(table: string, columns: readonly string[]): string;
+/** The constraint name a foreign key gets when nothing named it: `fk_Order_customerId`. */
+export declare function derivedForeignKeyName(table: string, columns: readonly string[]): string;
 /**
  * Escape a SQL identifier (table name, column name, etc.)
  * @param val the identifier to escape

package/dist/util/sql.util.js

@@ -48,6 +48,29 @@ export function obtainAttrsPaths(row) {
     }
     return paths;
 }
+/**
+ * A name behind its namespace, or bare where there is none: the one place the two are joined, so a
+ * table's key, its statement operand and its escaped form cannot spell it differently. Never the
+ * seed for a derived identifier - an index or constraint name is a single identifier, and
+ * `idx_sales.Order_total` is a syntax error.
+ */
+export function qualifyName(name, schema) {
+    return schema ? `${schema}.${name}` : name;
+}
+/**
+ * The name a derived index or constraint gets when nothing named it: `idx_Order_total`.
+ *
+ * One owner, because it is a rule two layers apply and a third has to match: the entity AST derives
+ * it, the DDL generator falls back to it, and a diff compares what the database reports against it.
+ * `table` is the table's own name, never qualified - the result is a single identifier.
+ */
+export function derivedIndexName(table, columns) {
+    return `idx_${table}_${columns.join('_')}`;
+}
+/** The constraint name a foreign key gets when nothing named it: `fk_Order_customerId`. */
+export function derivedForeignKeyName(table, columns) {
+    return `fk_${table}_${columns.join('_')}`;
+}
 /**
  * Escape a SQL identifier (table name, column name, etc.)
  * @param val the identifier to escape

package/package.json

@@ -3,7 +3,7 @@
   "homepage": "https://uql-orm.dev",
   "description": "JSON-native TypeScript ORM for Node.js, Bun and Deno. Supports PostgreSQL, PGlite, MySQL, MariaDB, SQLite, CockroachDB, Turso, Neon, Cloudflare D1 and MongoDB. Queries are plain JSON, typed to the leaf.",
   "license": "MIT",
-  "version": "0.33.0",
+  "version": "0.34.1",
   "type": "module",
   "engines": {
     "node": ">=24"