uql-orm 0.63.0 → 0.64.0

package/dist/schema/schemaASTBuilder.js

@@ -6,7 +6,7 @@
  * - Database introspection results (TableSchema[])
  */
 import { getMeta, soleIdOf } from '../entity/metadata/definition.js';
-import { indexNameParts, renderIndexColumn } from '../util/ddlExpression.util.js';
+import { declaredIndexes, indexNameParts, renderIndexColumn } from '../util/ddlExpression.util.js';
 import { isInlinedExpression } from '../util/field.util.js';
 import { isSoleIdField } from '../util/field.util.js';
 import { isAutoIncrement } from '../util/field.util.js';
@@ -23,6 +23,7 @@ import { DEFAULT_FOREIGN_KEY_ACTION, } from './types.js';
  */
 export function buildSchemaAST(entities, options = {}) {
     const { namingStrategy } = options;
+    const compileDdl = options.compileDdl ?? refuseDdl;
     const ctx = {
         ast: new SchemaAST(),
         resolveTableName: options.resolveTableName ??
@@ -30,7 +31,8 @@ export function buildSchemaAST(entities, options = {}) {
         resolveSchema: options.resolveSchema ?? ((m) => m.schema),
         resolveColumnName: options.resolveColumnName ?? ((k, f) => namingStrategy?.columnName(f.name ?? k) ?? f.name ?? k),
         defaultForeignKeyAction: options.defaultForeignKeyAction ?? DEFAULT_FOREIGN_KEY_ACTION,
-        compileDdl: options.compileDdl ?? refuseDdl,
+        compileDdl,
+        compileIndexPredicate: options.compileIndexPredicate ?? compileDdl,
     };
     for (const pass of [addTableFromEntity, addRelationshipsFromEntity, addIndexesFromEntity]) {
         for (const entity of entities) {
@@ -180,23 +182,7 @@ function addIndexesFromEntity(ctx, meta) {
     const table = tableOf(ctx, meta);
     if (!table)
         return;
-    for (const key of Object.keys(meta.fields)) {
-        const field = meta.fields[key];
-        if (!field?.index)
-            continue;
-        const column = table.columns.get(ctx.resolveColumnName(key, field));
-        if (!column)
-            continue;
-        ctx.ast.addIndex({
-            name: typeof field.index === 'string' ? field.index : derivedIndexName(table.name, [column.name]),
-            table,
-            entries: [{ column: column.name }],
-            unique: field.unique ?? false,
-            source: 'entity',
-            syncStatus: 'entity_only',
-        });
-    }
-    for (const idxMeta of meta.indexes ?? []) {
+    for (const idxMeta of declaredIndexes(meta)) {
         addCompositeIndex(ctx, table, meta, idxMeta);
     }
     addForeignKeyIndexes(ctx, meta, table);
@@ -235,7 +221,7 @@ function resolveIncludeColumn(ctx, meta, column) {
     return field ? ctx.resolveColumnName(column, field) : column;
 }
 /**
- * One `@Index`. Its entries keep the authored form (expression, prefix length, order) with
+ * One index the entity declares. Its entries keep the authored form (expression, prefix length, order) with
  * names resolved, so the generator renders exactly what was declared; `columns` is the resolvable
  * subset, which is what diffing and introspection compare.
  */
@@ -251,14 +237,15 @@ function addCompositeIndex(ctx, table, meta, idxMeta) {
     });
     if (!resolved.length)
         return;
+    const name = idxMeta.name ?? derivedIndexName(table.name, indexNameParts(resolved));
     ctx.ast.addIndex({
-        name: idxMeta.name ?? derivedIndexName(table.name, indexNameParts(resolved)),
+        name,
         table,
         entries: resolved.map((entry) => renderIndexColumn(entry, (sql) => ctx.compileDdl(sql, meta.entity))),
         include: idxMeta.include?.map((column) => resolveIncludeColumn(ctx, meta, column)),
         unique: idxMeta.unique ?? false,
         type: idxMeta.type,
-        where: idxMeta.where && ctx.compileDdl(idxMeta.where, meta.entity),
+        where: idxMeta.where && ctx.compileIndexPredicate(idxMeta.where, meta.entity, name),
         distance: idxMeta.distance,
         m: idxMeta.m,
         efConstruction: idxMeta.efConstruction,

package/dist/type/migration.d.ts

@@ -1,8 +1,8 @@
 import type { VectorCast } from '../dialect/vectorCast.js';
-import type { FullColumnDefinition, IndexDefinition, TableDefinition } from '../migrate/builder/types.js';
+import type { AnyMigrationOperation } from '../migrate/builder/types.js';
 import type { IndexFacet } from '../schema/indexDifferences.js';
 import type { SchemaAST } from '../schema/schemaAST.js';
-import type { ColumnNode, ForeignKeyAction, IndexNode, IndexType, TableNode } from '../schema/types.js';
+import type { ColumnNode, ForeignKeyAction, IndexType, TableNode } from '../schema/types.js';
 import type { EntityMeta, EntityWhereMeta, FieldOptions, IndexColumnSchema, LoggingOptions, Querier, SqlQuerier, Type, VectorIndexOptions } from './index.js';
 /**
  * Defines a migration using a simple object literal. `Q` is `MongoQuerier` for a MongoDB migration.
@@ -148,7 +148,7 @@ export interface IndexSchema extends VectorIndexOptions {
     readonly unique: boolean;
     /** Index type (btree, hnsw, ivfflat, etc.) */
     readonly type?: IndexType;
-    /** Partial index condition (WHERE clause) */
+    /** Partial index predicate as its engine writes it: SQL, or on MongoDB the JSON of its filter document. */
     readonly where?: string;
     /** Non-key columns stored in the index (Postgres-wire `INCLUDE`). */
     readonly include?: readonly string[];
@@ -292,14 +292,20 @@ export interface SchemaGenerator {
      */
     generateDropIndex(tableName: string, indexName: string): string;
     /**
-     * Get the SQL type for a field based on its options
+     * The statements one migration builder operation runs as, one string each. An operation the engine
+     * has no form for throws: MongoDB has no columns, constraints or SQL.
      */
-    getSqlType(fieldOptions: FieldOptions): string;
+    generateOperation(operation: AnyMigrationOperation): string[];
     /**
      * The text of SQL an entity declares - a check, a stored computed column, an index expression or
      * predicate - rendered for this engine, which is what building an entity's schema needs from it.
      */
     compileDdl(sql: EntityWhereMeta<object>, entity: Type<object>): string;
+    /**
+     * A partial index's `$where` as this engine writes it into {@link IndexSchema.where}, refused where its
+     * index takes less of a predicate than a query does: SQL Server's filter has no `OR`.
+     */
+    compileIndexPredicate(where: EntityWhereMeta<object>, entity: Type<object>, indexName: string): string;
     /**
      * Compare an entity with a database table node and return the differences.
      *
@@ -333,41 +339,6 @@ export interface SchemaGenerator {
      * Resolve column name using field options and naming strategy
      */
     resolveColumnName(key: string, field: FieldOptions): string;
-    /** DDL from a `TableNode`, one string per `querier.run`. */
-    generateCreateTableFromNode(table: TableNode, options?: {
-        ifNotExists?: boolean;
-    }): string[];
-    /** Generate CREATE INDEX statement from an IndexNode */
-    generateCreateIndexFromNode(index: IndexNode, options?: {
-        ifNotExists?: boolean;
-    }): string;
-    /** DDL from a `TableDefinition`, one string per `querier.run`. */
-    generateCreateTableFromDefinition(table: TableDefinition, options?: {
-        ifNotExists?: boolean;
-    }): string[];
-    /** Generate RENAME TABLE statement */
-    generateRenameTableSql(oldName: string, newName: string): string;
-}
-/**
- * The column and constraint DDL a migration builder emits, which only a SQL engine has. Split from
- * {@link SchemaGenerator} because MongoDB used to satisfy these six by returning `''`: a document store
- * has no `ADD COLUMN`, and an empty statement silently did nothing rather than saying so.
- */
-export interface SqlDdlGenerator extends SchemaGenerator {
-    /** Generate ADD COLUMN statement */
-    generateAddColumnSql(tableName: string, column: FullColumnDefinition): string;
-    /** Generate ALTER COLUMN statement */
-    generateAlterColumnSql(tableName: string, columnName: string, column: FullColumnDefinition): string;
-    /** Generate DROP COLUMN statement */
-    generateDropColumnSql(tableName: string, columnName: string): string;
-    /** Generate RENAME COLUMN statement */
-    generateRenameColumnSql(tableName: string, oldName: string, newName: string): string;
-    /** Generate ADD FOREIGN KEY statement */
-    generateAddForeignKeySql(tableName: string, foreignKey: ForeignKeySchema): string;
-    /** Generate DROP FOREIGN KEY statement */
-    generateDropForeignKeySql(tableName: string, constraintName: string): string;
-    /** CREATE INDEX from a builder's {@link IndexDefinition}, its SQL rendered for this engine. */
-    generateCreateIndexFromDefinition(tableName: string, index: IndexDefinition): string;
 }
 /**
  * Interface for introspecting the current database schema

package/dist/util/ddlExpression.util.d.ts

@@ -1,9 +1,11 @@
-import { type EntityIndexColumn, type IndexColumnInput, type IndexColumnSchema, QueryRaw } from '../type/index.js';
+import { type EntityIndexColumn, type EntityIndexMeta, type EntityMeta, type IndexColumnInput, type IndexColumnSchema, QueryRaw } from '../type/index.js';
 /**
  * Reduces an authored index entry to the form metadata keeps, so a column, an expression and an options
  * object reach the schema as one: a column read off the refs as its key, any other `raw` as it is.
  */
 export declare function normalizeIndexColumn(entry: IndexColumnInput): EntityIndexColumn;
+/** Every index an entity declares: each `@Field({ index })` as the one-column `@Index` it is, then its `@Index`es. */
+export declare function declaredIndexes<E>(meta: EntityMeta<E>): EntityIndexMeta<E>[];
 /** An index entry as the schema holds it, its expression rendered to text by `render`. */
 export declare function renderIndexColumn(entry: EntityIndexColumn, render: (sql: QueryRaw) => string): IndexColumnSchema;
 /** What an unnamed index's name is built from: each entry's column, or `expr<n>` for an expression, which has none. */

package/dist/util/ddlExpression.util.js

@@ -1,4 +1,5 @@
 import { ColumnRef, QueryRaw, } from '../type/index.js';
+import { definedEntries } from './object.util.js';
 /**
  * Reduces an authored index entry to the form metadata keeps, so a column, an expression and an options
  * object reach the schema as one: a column read off the refs as its key, any other `raw` as it is.
@@ -7,6 +8,19 @@ export function normalizeIndexColumn(entry) {
     const { column, ...modifiers } = typeof entry === 'string' || entry instanceof QueryRaw ? { column: entry } : entry;
     return { ...modifiers, column: column instanceof ColumnRef ? column.key : column };
 }
+/** Every index an entity declares: each `@Field({ index })` as the one-column `@Index` it is, then its `@Index`es. */
+export function declaredIndexes(meta) {
+    const fieldIndexes = definedEntries(meta.fields).flatMap(([key, field]) => field.index
+        ? [
+            {
+                columns: [{ column: key }],
+                name: typeof field.index === 'string' ? field.index : undefined,
+                unique: field.unique,
+            },
+        ]
+        : []);
+    return [...fieldIndexes, ...(meta.indexes ?? [])];
+}
 /** An index entry as the schema holds it, its expression rendered to text by `render`. */
 export function renderIndexColumn(entry, render) {
     const { column } = entry;

package/dist/util/sqlLiteral.js

@@ -32,7 +32,6 @@ const MYSQL_ESCAPES = {
     '\\': '\\\\',
 };
 const mysqlStringLiteral = (val) => `'${val.replace(MYSQL_SPECIALS, (char) => MYSQL_ESCAPES[char])}'`;
-const pad = (value, len) => String(value).padStart(len, '0');
 const HEX_BYTES = Array.from({ length: 256 }, (_, byte) => byte.toString(16).padStart(2, '0'));
 /** Native hex encoder where available (~130x faster on 4 KB); lookup table for browsers. */
 function bytesToHexLiteral(bytes) {
@@ -49,8 +48,11 @@ function bytesToHexLiteral(bytes) {
  * measured 1.1-1.5x slower. Rejects unsupported types rather than stringifying them into SQL.
  */
 function createEscaper(escapeString) {
-    /** `YYYY-MM-DD HH:mm:ss.mmm` in local time, wrapped as a quoted literal. */
-    const dateLiteral = (date) => escapeString(`${pad(date.getFullYear(), 4)}-${pad(date.getMonth() + 1, 2)}-${pad(date.getDate(), 2)} ${pad(date.getHours(), 2)}:${pad(date.getMinutes(), 2)}:${pad(date.getSeconds(), 2)}.${pad(date.getMilliseconds(), 3)}`);
+    /**
+     * `YYYY-MM-DD HH:mm:ss.SSS` in UTC, so the SQL is the same whichever machine wrote it. Not `toISOString`
+     * as it is, whose `T` and `Z` MySQL rejects outright ("Invalid default value").
+     */
+    const dateLiteral = (date) => escapeString(date.toISOString().replace('T', ' ').replace('Z', ''));
     const sqlList = (arr) => {
         let sql = '';
         for (let i = 0; i < arr.length; i++) {

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.63.0",
+  "version": "0.64.0",
   "type": "module",
   "engines": {
     "node": ">=24"

package/dist/migrate/schemaGeneratorAsync.d.ts

@@ -1,7 +0,0 @@
-import type { ForeignKeyAction } from '../schema/types.js';
-import type { MigratorDialect, SchemaGenerator } from '../type/index.js';
-/**
- * Async factory for schema generators. Use this for MongoDB so the optional peer
- * `mongodb` is only loaded when this path runs. SQL dialects delegate to {@link createSchemaGenerator}.
- */
-export declare function createSchemaGeneratorAsync(dialect: MigratorDialect, defaultForeignKeyAction?: ForeignKeyAction): Promise<SchemaGenerator | undefined>;

package/dist/migrate/schemaGeneratorAsync.js

@@ -1,12 +0,0 @@
-import { createSchemaGenerator } from './schemaGenerator.js';
-/**
- * Async factory for schema generators. Use this for MongoDB so the optional peer
- * `mongodb` is only loaded when this path runs. SQL dialects delegate to {@link createSchemaGenerator}.
- */
-export async function createSchemaGeneratorAsync(dialect, defaultForeignKeyAction) {
-    if (dialect.dialectName === 'mongodb') {
-        const { MongoSchemaGenerator } = await import('./generator/mongoSchemaGenerator.js');
-        return new MongoSchemaGenerator(dialect.namingStrategy, defaultForeignKeyAction);
-    }
-    return createSchemaGenerator(dialect, defaultForeignKeyAction);
-}