uql-orm 0.24.7 → 0.25.0

package/README.md

@@ -51,7 +51,7 @@ from the browser to the server. The same object runs on every supported database
 ## Why UQL?
 
 - **The fastest.** Wins [all 8 categories](https://uql-orm.dev/benchmark) of our open-source [benchmark](https://github.com/rogerpadilla/ts-orm-benchmark), beating even query builders like Knex and Kysely: ~2.4× faster than the runner-up on average, reaching over 4.6M ops/s on simple SELECTs.
-- **Light.** Zero runtime dependencies, 288 kB on the wire, every dialect included. See [what we deleted to get there](https://uql-orm.dev/blog/zero-dependencies).
+- **Light.** Zero runtime dependencies, 305 kB on the wire, every dialect included. See [what we deleted to get there](https://uql-orm.dev/blog/zero-dependencies).
 - **Queries are data (JSON), not method chains.** Plain JSON in, typed rows out. There's no DSL to learn and nothing to compile.
 - **Type-safe to the leaf.** Every key is autocompleted and checked against your entity, down to the fields of a populated relation. Operators are gated per field type, and [JSON/JSONB](https://uql-orm.dev/querying/json) dot-paths resolve each path's value type, so `$like` on a numeric column, or a typo'd path, is a compile error instead of a runtime surprise.
 - **No codegen, no build step.** Entities are TypeScript classes, so your code *is* the schema. There's no `.prisma` file to regenerate and no generated client to keep in sync.

package/dist/dialect/abstractSqlDialect.js

@@ -534,7 +534,11 @@ export class AbstractSqlDialect extends IndexSqlDialect {
         }
     }
     appendInNin(ctx, field, op, val) {
-        this.appendFieldSql(ctx, field, this.formatIn(ctx, Array.isArray(val) ? val : [], op === '$nin'));
+        if (!Array.isArray(val)) {
+            // Not covered by the types: `/http` casts client JSON straight to `Query`, so this arrives untyped.
+            throw TypeError(`${op} expects an array, got ${val === null ? 'null' : typeof val}`);
+        }
+        this.appendFieldSql(ctx, field, this.formatIn(ctx, val, op === '$nin'));
     }
     /**
      * Build a comparison condition for a JSON field.

package/dist/migrate/generator/mongoSchemaGenerator.d.ts

@@ -1,6 +1,6 @@
 import { AbstractDialect } from '../../dialect/abstractDialect.js';
 import type { ForeignKeyAction, IndexNode, TableNode } from '../../schema/types.js';
-import type { FieldOptions, IndexSchema, InsertIdSource, NamingStrategy, SchemaDiff, SchemaGenerator, Type } from '../../type/index.js';
+import type { CreateSchemaOptions, FieldOptions, IndexSchema, InsertIdSource, NamingStrategy, SchemaDiff, SchemaGenerator, Type } from '../../type/index.js';
 import type { TableDefinition } from '../builder/types.js';
 export declare class MongoSchemaGenerator extends AbstractDialect implements SchemaGenerator {
     protected readonly defaultForeignKeyAction?: ForeignKeyAction | undefined;
@@ -8,6 +8,14 @@ export declare class MongoSchemaGenerator extends AbstractDialect implements Sch
     protected readonly featureDefaults: import("../../type/dialect.js").DialectFeatures;
     readonly insertIdSource: InsertIdSource;
     constructor(namingStrategy?: NamingStrategy, defaultForeignKeyAction?: ForeignKeyAction | undefined);
+    /**
+     * A document store has no cross-collection constraint, so unlike the SQL generator there is nothing to
+     * defer and no order to respect: this is each collection and nothing more. `foreignKeys` is accepted
+     * and ignored for the same reason.
+     */
+    generateCreateSchema(entities: readonly Type<unknown>[], options?: CreateSchemaOptions): string[];
+    generateDropSchema(entities: readonly Type<unknown>[]): string[];
+    private selected;
     generateCreateTable<E>(entity: Type<E>, _options?: {
         ifNotExists?: boolean;
     }): string[];

package/dist/migrate/generator/mongoSchemaGenerator.js

@@ -13,6 +13,24 @@ export class MongoSchemaGenerator extends AbstractDialect {
         super({ namingStrategy });
         this.defaultForeignKeyAction = defaultForeignKeyAction;
     }
+    /**
+     * A document store has no cross-collection constraint, so unlike the SQL generator there is nothing to
+     * defer and no order to respect: this is each collection and nothing more. `foreignKeys` is accepted
+     * and ignored for the same reason.
+     */
+    generateCreateSchema(entities, options) {
+        return this.selected(entities, options?.only).flatMap((entity) => this.generateCreateTable(entity, options));
+    }
+    generateDropSchema(entities) {
+        return this.selected(entities).map((entity) => this.generateDropTable(this.resolveTableName(entity, getMeta(entity))));
+    }
+    selected(entities, only) {
+        if (!only) {
+            return entities;
+        }
+        const wanted = new Set(only);
+        return entities.filter((entity) => wanted.has(this.resolveTableName(entity, getMeta(entity))));
+    }
     generateCreateTable(entity, _options) {
         const meta = getMeta(entity);
         const collectionName = this.resolveTableName(entity, meta);

package/dist/migrate/migrator.d.ts

@@ -104,6 +104,15 @@ export declare class Migrator {
         safe?: boolean;
         drop?: boolean;
     }): Promise<string[]>;
+    /**
+     * New tables are emitted together, never one at a time: a single-entity AST has no other table for a
+     * relation to resolve against, so every cross-entity foreign key was dropped and generated schemas
+     * carried none. Spanning the graph is also what lets a cyclic relation (any `createdBy`
+     * back-reference) be created at all.
+     *
+     * Empty in, empty out, so a diff with no new tables does not build an AST for the whole graph.
+     */
+    private createSchema;
     /**
      * Each pending diff with the entity it came from, since resolving that is async and every caller
      * needs it. What to emit stays with the caller: a sync narrows the forward direction to what the

package/dist/migrate/migrator.js

@@ -234,20 +234,22 @@ export class Migrator {
      * Generate a migration based on entity schema differences
      */
     async generateFromEntities(name) {
-        const upStatements = [];
+        const creating = [];
+        const altering = [];
         const downStatements = [];
         for (const { diff, entity } of await this.pendingDiffs()) {
             if (diff.type === 'create') {
                 if (entity) {
-                    upStatements.push(...this.generator.generateCreateTable(entity));
+                    creating.push(diff.tableName);
                     downStatements.push(this.generator.generateDropTable(diff.tableName, { ifExists: true }));
                 }
             }
             else if (diff.type === 'alter') {
-                upStatements.push(...this.generator.generateAlterTable(diff));
+                altering.push(...this.generator.generateAlterTable(diff));
                 downStatements.push(...this.generator.generateAlterTableDown(diff));
             }
         }
+        const upStatements = [...this.createSchema(creating), ...altering];
         if (upStatements.length === 0) {
             this.logger.logInfo('No schema changes detected.');
             return '';
@@ -317,21 +319,18 @@ export class Migrator {
      */
     async syncForce() {
         await this.ensureSchemaGenerator();
+        // Both directions span the whole entity set rather than looping an entity at a time. A per-entity
+        // AST cannot resolve a cross-entity foreign key, so the old create loop silently produced a schema
+        // with no referential integrity; and the old drop loop went in reverse *declaration* order, which
+        // says nothing about the relation graph and is rejected as soon as the constraints are really there.
+        const statements = [
+            ...this.generator.generateDropSchema(this.entities, { ifExists: true, cascade: true }),
+            ...this.generator.generateCreateSchema(this.entities),
+        ];
         await withSqlQuerierForMigrations(this.pool, 'Migrator', (querier) => querier.transaction(async () => {
-            // Drop all tables first (in reverse order for foreign keys)
-            for (const entity of [...this.entities].reverse()) {
-                const tableName = this.generator.resolveTableName(entity, getMeta(entity));
-                const dropSql = this.generator.generateDropTable(tableName, { ifExists: true });
-                this.logger.logSchema(`Executing: ${dropSql}`);
-                await querier.run(dropSql);
-            }
-            // Create all tables
-            for (const entity of this.entities) {
-                const createStmts = this.generator.generateCreateTable(entity);
-                for (const createSql of createStmts) {
-                    this.logger.logSchema(`Executing: ${createSql}`);
-                    await querier.run(createSql);
-                }
+            for (const sql of statements) {
+                this.logger.logSchema(`Executing: ${sql}`);
+                await querier.run(sql);
             }
         }));
         this.logger.logSchema('Schema sync (force) completed');
@@ -353,17 +352,29 @@ export class Migrator {
      * statements rather than a summary of a second, differently-computed diff.
      */
     async planSync(options = {}) {
-        const statements = [];
+        const creating = [];
+        const altering = [];
         for (const { diff, entity } of await this.pendingDiffs()) {
             if (diff.type === 'create') {
                 if (entity)
-                    statements.push(...this.generator.generateCreateTable(entity));
+                    creating.push(diff.tableName);
             }
             else if (diff.type === 'alter') {
-                statements.push(...this.generator.generateAlterTable(this.filterDiff(diff, options)));
+                altering.push(...this.generator.generateAlterTable(this.filterDiff(diff, options)));
             }
         }
-        return statements;
+        return [...this.createSchema(creating), ...altering];
+    }
+    /**
+     * New tables are emitted together, never one at a time: a single-entity AST has no other table for a
+     * relation to resolve against, so every cross-entity foreign key was dropped and generated schemas
+     * carried none. Spanning the graph is also what lets a cyclic relation (any `createdBy`
+     * back-reference) be created at all.
+     *
+     * Empty in, empty out, so a diff with no new tables does not build an AST for the whole graph.
+     */
+    createSchema(tableNames) {
+        return tableNames.length ? this.generator.generateCreateSchema(this.entities, { only: tableNames }) : [];
     }
     /**
      * Each pending diff with the entity it came from, since resolving that is async and every caller

package/dist/migrate/schemaGenerator.d.ts

@@ -1,6 +1,6 @@
 import { type AbstractDialect, AbstractSqlDialect } from '../dialect/index.js';
 import type { CanonicalType, ColumnNode, ForeignKeyAction, IndexNode, TableNode } from '../schema/types.js';
-import type { ColumnSchema, DialectFeatures, EntityMeta, FieldOptions, IndexSchema, NamingStrategy, SchemaDiff, SqlDdlGenerator, Type } from '../type/index.js';
+import type { ColumnSchema, CreateSchemaOptions, DialectFeatures, DropSchemaOptions, EntityMeta, FieldOptions, IndexSchema, NamingStrategy, SchemaDiff, SqlDdlGenerator, Type } from '../type/index.js';
 import type { FullColumnDefinition, TableDefinition, TableForeignKeyDefinition } from './builder/types.js';
 /**
  * Unified SQL schema generator.
@@ -27,13 +27,24 @@ export declare class SqlSchemaGenerator implements SqlDdlGenerator {
      */
     protected getCanonicalType(field: FieldOptions, fieldType?: unknown): CanonicalType;
     protected canonicalTypeToSql(type: CanonicalType): string;
-    generateCreateTable<E>(entity: Type<E>, options?: {
-        ifNotExists?: boolean;
-    }): string[];
-    generateDropTable(tableName: string, options?: {
-        ifExists?: boolean;
-        cascade?: boolean;
-    }): string;
+    /**
+     * Every `CREATE TABLE` for `entities`, then their foreign keys.
+     *
+     * Two phases rather than inline constraints, because a relation graph is routinely cyclic: any
+     * `createdBy`-style back-reference makes `A` reference `B` while `B` references `A`, and no create
+     * order satisfies that. TypeORM's schema builder splits for the same reason (`createNewTables()`
+     * then `createForeignKeys()`). SQLite is the exception and keeps them inline: it cannot `ALTER` a
+     * foreign key in, but it resolves targets lazily, so a forward reference is fine there.
+     */
+    generateCreateSchema(entities: readonly Type<unknown>[], options?: CreateSchemaOptions): string[];
+    generateDropSchema(entities: readonly Type<unknown>[], options?: DropSchemaOptions): string[];
+    /**
+     * The tables of `entities` in dependency order, optionally narrowed to `only`. The AST always spans
+     * every entity even when narrowed, so a relation pointing at a table outside the subset still
+     * resolves instead of being silently dropped.
+     */
+    private orderedTables;
+    generateDropTable(tableName: string, options?: DropSchemaOptions): string;
     generateAlterTable(diff: SchemaDiff): string[];
     generateAlterTableDown(diff: SchemaDiff): string[];
     generateCreateIndex(tableName: string, index: IndexSchema, options?: {

package/dist/migrate/schemaGenerator.js

@@ -49,11 +49,54 @@ export class SqlSchemaGenerator {
     canonicalTypeToSql(type) {
         return canonicalToSql(type, this.dialect);
     }
-    generateCreateTable(entity, options = {}) {
-        const builder = new SchemaASTBuilder(this.dialect.namingStrategy);
-        const ast = builder.fromEntities([entity]);
-        const tableNode = ast.getTables()[0];
-        return this.generateCreateTableFromNode(tableNode, options);
+    /**
+     * Every `CREATE TABLE` for `entities`, then their foreign keys.
+     *
+     * Two phases rather than inline constraints, because a relation graph is routinely cyclic: any
+     * `createdBy`-style back-reference makes `A` reference `B` while `B` references `A`, and no create
+     * order satisfies that. TypeORM's schema builder splits for the same reason (`createNewTables()`
+     * then `createForeignKeys()`). SQLite is the exception and keeps them inline: it cannot `ALTER` a
+     * foreign key in, but it resolves targets lazily, so a forward reference is fine there.
+     */
+    generateCreateSchema(entities, options = {}) {
+        const tables = this.orderedTables(entities, 'create', options.only);
+        const withForeignKeys = options.foreignKeys ?? true;
+        // Inline only where a constraint cannot be added afterwards, which is what makes the cyclic case
+        // work everywhere else.
+        const inline = withForeignKeys && !this.features.foreignKeyAlter;
+        const statements = tables.flatMap((table) => this.generateCreateTableFromNode(inline ? table : { ...table, outgoingRelations: [] }, options));
+        if (withForeignKeys && !inline) {
+            for (const table of tables) {
+                for (const rel of table.outgoingRelations) {
+                    statements.push(this.generateAddForeignKeySql(table.name, {
+                        name: rel.name,
+                        columns: rel.from.columns.map((c) => c.name),
+                        referencesTable: rel.to.table.name,
+                        referencesColumns: rel.to.columns.map((c) => c.name),
+                        onDelete: rel.onDelete ?? this.defaultForeignKeyAction,
+                        onUpdate: rel.onUpdate ?? this.defaultForeignKeyAction,
+                    }));
+                }
+            }
+        }
+        return statements;
+    }
+    generateDropSchema(entities, options = {}) {
+        return this.orderedTables(entities, 'drop').map((table) => this.generateDropTable(table.name, options));
+    }
+    /**
+     * The tables of `entities` in dependency order, optionally narrowed to `only`. The AST always spans
+     * every entity even when narrowed, so a relation pointing at a table outside the subset still
+     * resolves instead of being silently dropped.
+     */
+    orderedTables(entities, direction, only) {
+        const ast = new SchemaASTBuilder(this.dialect.namingStrategy).fromEntities(entities);
+        const tables = direction === 'create' ? ast.getCreateOrder() : ast.getDropOrder();
+        if (!only) {
+            return tables;
+        }
+        const wanted = new Set(only);
+        return tables.filter((table) => wanted.has(table.name));
     }
     generateDropTable(tableName, options = {}) {
         const ifExists = options.ifExists ? 'IF EXISTS ' : '';

package/dist/querier/abstractSqlQuerier.js

@@ -231,10 +231,12 @@ export class AbstractSqlQuerier extends AbstractQuerier {
             return 0;
         }
         const ids = founds.map((it) => it[meta.id]);
+        // Children first: they hold the foreign key, so deleting the parent ahead of them is rejected
+        // outright by any schema that declares the constraint without `ON DELETE CASCADE`.
+        await this.deleteRelations(entity, ids, opts);
         const deleteCtx = this.dialect.createContext();
         this.dialect.delete(deleteCtx, entity, { $where: ids }, opts);
         const { changes = 0 } = await this.run(deleteCtx.sql, deleteCtx.values);
-        await this.deleteRelations(entity, ids, opts);
         return changes;
     }
     get hasOpenTransaction() {

package/dist/schema/schemaASTBuilder.d.ts

@@ -41,7 +41,7 @@ export declare class SchemaASTBuilder {
     /**
      * Build AST from entity classes (decorated with @Entity, @Field, etc.)
      */
-    fromEntities(entities: Type<unknown>[], options?: BuildFromEntitiesOptions): SchemaAST;
+    fromEntities(entities: readonly Type<unknown>[], options?: BuildFromEntitiesOptions): SchemaAST;
     /**
      * Resolve the canonical type for a field, inheriting from the referenced
      * entity's primary key when the field is a foreign-key reference

package/dist/schema/schemaASTBuilder.js

@@ -181,8 +181,10 @@ export class SchemaASTBuilder {
                         type: relation.cardinality === 'm1' ? 'ManyToOne' : 'OneToOne',
                         from: { table, columns: [localColumn] },
                         to: { table: relatedTable, columns: [foreignColumn] },
-                        onDelete: options.defaultForeignKeyAction ?? this.defaultForeignKeyAction,
-                        onUpdate: options.defaultForeignKeyAction ?? this.defaultForeignKeyAction,
+                        // The relation's own action wins over the global default, so one relation can cascade in the
+                        // database while the rest stay on `NO ACTION`.
+                        onDelete: relation.onDelete ?? options.defaultForeignKeyAction ?? this.defaultForeignKeyAction,
+                        onUpdate: relation.onUpdate ?? options.defaultForeignKeyAction ?? this.defaultForeignKeyAction,
                         confidence: 1.0,
                         inferredFrom: 'entity_decorator',
                     };

package/dist/sqlite/nodeSqliteQuerierPool.js

@@ -24,6 +24,7 @@ export class NodeSqliteQuerierPool extends AbstractLocalSqliteQuerierPool {
             ...(extensions?.length ? { allowExtension: true } : undefined),
         });
         nodeDb.exec('PRAGMA journal_mode = WAL');
+        nodeDb.exec('PRAGMA foreign_keys = ON');
         return adaptNodeSqlite(nodeDb);
     }
 }

package/dist/sqlite/sqliteQuerierPool.d.ts

@@ -11,5 +11,10 @@ export type Sqlite3PoolOptions = Options & LocalSqlitePoolOptions;
 export declare class Sqlite3QuerierPool extends AbstractLocalSqliteQuerierPool<Sqlite3PoolOptions> {
     readonly filename: string | Buffer;
     constructor(filename?: string | Buffer, opts?: Sqlite3PoolOptions, extra?: ExtraOptions);
+    /**
+     * SQLite ships with foreign keys unenforced, per connection, for backward compatibility. UQL emits the
+     * constraints in its DDL, so leaving them off means a declared `onDelete: 'CASCADE'` silently does
+     * nothing and a dangling reference is accepted. Enabled here on every driver, as TypeORM also does.
+     */
     protected createDb(): Promise<SqliteDatabase>;
 }

package/dist/sqlite/sqliteQuerierPool.js

@@ -9,6 +9,11 @@ export class Sqlite3QuerierPool extends AbstractLocalSqliteQuerierPool {
         super(opts, extra);
         this.filename = filename;
     }
+    /**
+     * SQLite ships with foreign keys unenforced, per connection, for backward compatibility. UQL emits the
+     * constraints in its DDL, so leaving them off means a declared `onDelete: 'CASCADE'` silently does
+     * nothing and a dangling reference is accepted. Enabled here on every driver, as TypeORM also does.
+     */
     async createDb() {
         // `bun:sqlite` rejects option keys it does not know, and rejects an options object carrying no
         // open flags, so `extensions` is stripped out and what remains of it collapses back to nothing.
@@ -19,11 +24,13 @@ export class Sqlite3QuerierPool extends AbstractLocalSqliteQuerierPool {
             const { adaptBunSqlite } = await import('./bunSqliteAdapter.bun.js');
             const bunDb = new BunDatabase(this.filename, opts);
             bunDb.run('PRAGMA journal_mode = WAL');
+            bunDb.run('PRAGMA foreign_keys = ON');
             return adaptBunSqlite(bunDb);
         }
         const { default: BetterSqlite3 } = await import('better-sqlite3');
         const db = new BetterSqlite3(this.filename, opts);
         db.pragma('journal_mode = WAL');
+        db.pragma('foreign_keys = ON');
         return db;
     }
 }

package/dist/turso/tursoLocalQuerierPool.js

@@ -30,6 +30,7 @@ export class TursoLocalQuerierPool extends AbstractSqlQuerierPool {
         // Annotated rather than cast, so the structural contract is checked against the real driver.
         const db = await connect(this.filename, this.opts);
         await db.pragma('journal_mode = WAL');
+        await db.pragma('foreign_keys = ON');
         return db;
     }
     async end() {

package/dist/type/entity.d.ts

@@ -1,4 +1,4 @@
-import type { IndexType } from '../schema/types.js';
+import type { ForeignKeyAction, IndexType } from '../schema/types.js';
 import type { FilterOptions } from './query.js';
 import type { QueryRaw } from './queryRaw.js';
 import type { DistributiveOmit, Json, Scalar, Type, Unpacked } from './utility.js';
@@ -362,6 +362,20 @@ export type RelationOptions<E = any> = {
     entity: EntityGetter<E>;
     cardinality: RelationCardinality;
     readonly cascade?: boolean | CascadeType;
+    /**
+     * Referential actions for the generated foreign key, letting the database do the work instead of the
+     * ORM: `onDelete: 'CASCADE'` makes deleting the parent a single statement rather than the graph walk
+     * `cascade` performs. Defaults to the migrator's `defaultForeignKeyAction`.
+     *
+     * Read only from the side that owns the key (`@ManyToOne`, or a `@OneToOne` without `mappedBy`),
+     * matching where TypeORM, Prisma and Drizzle put it. Not available on a bare `@Field({ references })`
+     * with no relation, because `FieldOptions.onUpdate` already means a value callback there.
+     *
+     * This overlaps `cascade` rather than conflicting with it: declaring both deletes the children in JS
+     * and then leaves the foreign key nothing to cascade, so pick one.
+     */
+    readonly onDelete?: ForeignKeyAction;
+    readonly onUpdate?: ForeignKeyAction;
     mappedBy?: RelationMappedBy<E>;
     /**
      * The pivot entity of a many-to-many. Unconstrained by `E`: a pivot holds foreign keys to both
@@ -392,7 +406,7 @@ type RelationOwnerJoin<E> = Required<Pick<RelationOptions<E>, 'through'>> | Requ
  * without one of the three, resolution has no columns to join on and throws.
  */
 type RelationJoin<E> = RelationOwnerJoin<E> | Required<Pick<RelationOptions<E>, 'mappedBy'>>;
-type RelationOptionsOwner<E> = Pick<RelationOptions<E>, 'entity' | 'references' | 'cascade'>;
+type RelationOptionsOwner<E> = Pick<RelationOptions<E>, 'entity' | 'references' | 'cascade' | 'onDelete' | 'onUpdate'>;
 type RelationOptionsInverseSide<E> = Pick<RelationOptions<E>, 'entity' | 'cascade'> & Required<Pick<RelationOptions<E>, 'mappedBy'>>;
 type RelationOptionsThroughOwner<E> = Pick<RelationOptions<E>, 'entity' | 'cascade'> & RelationOwnerJoin<E>;
 /**

package/dist/type/migration.d.ts

@@ -174,22 +174,43 @@ export interface SchemaDiff {
     readonly foreignKeysToAdd?: ForeignKeySchema[];
     readonly foreignKeysToDrop?: string[];
 }
+export interface CreateSchemaOptions {
+    readonly ifNotExists?: boolean;
+    /**
+     * Restrict which tables are created, for an incremental migration adding one table to a schema that
+     * already exists. Constraints still resolve against the full entity graph.
+     */
+    readonly only?: readonly string[];
+    /**
+     * Emit the tables without their foreign keys. Only the integration fixtures want this, and only until
+     * their data stops relying on dangling references; a migration always wants the constraints.
+     */
+    readonly foreignKeys?: boolean;
+}
+export interface DropSchemaOptions {
+    readonly ifExists?: boolean;
+    readonly cascade?: boolean;
+}
 /**
  * Interface for generating DDL statements from entity metadata
  */
 export interface SchemaGenerator {
     /**
-     * DDL to create an entity’s table: one element per `querier.run` (optional `CREATE EXTENSION`, `CREATE TABLE`, each `CREATE INDEX`, …).
-     * Join with `'\n'` if you need a single script blob.
+     * The whole schema for `entities`: every table, then the foreign keys between them.
+     *
+     * There is deliberately no per-entity counterpart. One entity means an AST holding one table, so every
+     * cross-entity foreign key has nothing to resolve against and is dropped: all three call sites that
+     * used to work that way emitted schemas with no referential integrity.
      */
-    generateCreateTable<E>(entity: Type<E>, options?: {
-        ifNotExists?: boolean;
-    }): string[];
+    generateCreateSchema(entities: readonly Type<unknown>[], options?: CreateSchemaOptions): string[];
+    /**
+     * Every `DROP TABLE` for `entities`, dependents first. The inverse of {@link generateCreateSchema},
+     * and the reason it takes the whole set: dropping in any order that ignores the relation graph is
+     * rejected once the foreign keys are really there.
+     */
+    generateDropSchema(entities: readonly Type<unknown>[], options?: DropSchemaOptions): string[];
     /** Generate DROP TABLE statement. */
-    generateDropTable(tableName: string, options?: {
-        ifExists?: boolean;
-        cascade?: boolean;
-    }): string;
+    generateDropTable(tableName: string, options?: DropSchemaOptions): string;
     /**
      * Generate ALTER TABLE statements based on schema diff
      */

package/package.json

@@ -3,7 +3,7 @@
   "homepage": "https://uql-orm.dev",
   "description": "Extremely fast, type-safe TypeScript ORM - one API for every database",
   "license": "MIT",
-  "version": "0.24.7",
+  "version": "0.25.0",
   "type": "module",
   "engines": {
     "node": ">=24"
@@ -141,8 +141,8 @@
     "mariadb": "^3.5.3",
     "mongodb": "^7.5.0",
     "mysql2": "^3.23.2",
-    "pg": "^8.22.0",
-    "pg-query-stream": "^4.16.0",
+    "pg": "^8.23.0",
+    "pg-query-stream": "^4.17.0",
     "rxjs": "^7.8.2",
     "sqlite-vec": "^0.1.9",
     "ws": "^8.21.3"
@@ -198,5 +198,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "26ffc7e2968761bc95a0bb1ffe0aeb37600ba1f1"
+  "gitHead": "cfe2b005308b808d2e6e3d6e062c13791c883d13"
 }