@depup/typeorm-extension 4.0.0-depup.0 → 4.1.0-depup.0

package/README.MD

@@ -27,6 +27,7 @@ This is a library to
     - [Create](#create)
     - [Drop](#drop)
     - [Schema Drift](#schema-drift)
+    - [Generate Migration](#generate-migration)
     - [Repair Migrations](#repair-migrations)
   - [Instances](#instances)
     - [Single](#single)
@@ -288,6 +289,27 @@ import { assertSchemaMatchesMetadata, getSchemaDrift } from 'typeorm-extension';
 
 The same check is available on the command line as `typeorm-extension db drift`, which exits with code `1` on drift.
 
+#### Generate Migration
+
+`generateMigration` writes a migration file from the same schema comparison, using typeorm's own statements and file
+templates. The data source must already be initialized.
+
+```typescript
+import { generateMigration } from 'typeorm-extension';
+
+(async () => {
+    await generateMigration({
+        dataSource,
+        name: 'add-role',
+        directoryPath: 'src/migrations',
+    });
+})();
+```
+
+The file is written as `<timestamp>-<name>.<language>`, by default into `migrations/`. Set `language: 'js'` (plus
+`esm: true` for `export class` syntax) for a JavaScript migration, or `preview: true` to receive the statements without
+writing a file.
+
 #### Repair Migrations
 
 Renaming a constraint is dialect-asymmetric and easy to get wrong. These helpers read the current state back from the

package/README.md

@@ -13,8 +13,8 @@ npm install @depup/typeorm-extension
 
 | Field | Value |
 |-------|-------|
-| Original | [typeorm-extension](https://www.npmjs.com/package/typeorm-extension) @ 4.0.0 |
-| Processed | 2026-08-16 |
+| Original | [typeorm-extension](https://www.npmjs.com/package/typeorm-extension) @ 4.1.0 |
+| Processed | 2026-08-23 |
 | Smoke test | failed |
 | Deps updated | 2 |
 

package/changes.json

@@ -9,6 +9,6 @@
       "to": "^1.6.2"
     }
   },
-  "timestamp": "2026-08-16T00:30:51.033Z",
+  "timestamp": "2026-08-23T00:28:11.616Z",
   "totalUpdated": 2
 }

package/dist/index.d.mts

@@ -592,7 +592,7 @@ type DatabaseCreateContext = Omit<DatabaseBaseContext, 'findOptions'> & {
    */
   synchronize: boolean;
 };
-type DatabaseCreateContextInput = Partial<DatabaseCreateContext>;
+type DatabaseCreateContextInput = Partial<DatabaseCreateContext> & Pick<DatabaseBaseContext, 'findOptions'>;
 type DatabaseDropContext = Omit<DatabaseBaseContext, 'findOptions'> & {
   /**
    * Only drop database if existed.
@@ -601,7 +601,7 @@ type DatabaseDropContext = Omit<DatabaseBaseContext, 'findOptions'> & {
    */
   ifExist?: boolean;
 };
-type DatabaseDropContextInput = Partial<DatabaseDropContext>;
+type DatabaseDropContextInput = Partial<DatabaseDropContext> & Pick<DatabaseBaseContext, 'findOptions'>;
 //#endregion
 //#region src/database/methods/create/module.d.ts
 /**
@@ -944,6 +944,19 @@ type MigrationGenerateCommandContext = {
    * Prettify sql statements.
    */
   prettify?: boolean;
+  /**
+   * Language of the generated migration file. It also determines the file extension.
+   *
+   * @default 'ts'
+   */
+  language?: 'ts' | 'js';
+  /**
+   * Generate an ESM (export class) instead of a CommonJS (module.exports) migration.
+   * Only applies to the language js.
+   *
+   * @default false
+   */
+  esm?: boolean;
   /**
    * Only return up- & down-statements instead of backing up the migration to the file system.
    */

package/dist/index.mjs

@@ -6,9 +6,9 @@ import { Brackets, DataSource, InstanceChecker, MigrationExecutor, MssqlParamete
 import { oneOf, read as read$1, readArray, readBool, readInt, toArray, toBool } from "envix";
 import { createMerger } from "smob";
 import { DriverFactory } from "typeorm/driver/DriverFactory.js";
-import { pascalCase } from "pascal-case";
-import process$1 from "node:process";
+import { CommandUtils } from "typeorm/commands/CommandUtils.js";
 import { MigrationGenerateCommand } from "typeorm/commands/MigrationGenerateCommand.js";
+import { pascalCase } from "pascal-case";
 //#region src/errors/base.ts
 var TypeormExtensionError = class extends Error {};
 //#endregion
@@ -2434,73 +2434,44 @@ async function dropDatabase(input = {}) {
 }
 //#endregion
 //#region src/database/utils/migration.ts
+/**
+* typeorm keeps the statement escaping, the query-parameter formatting and both file
+* templates as protected statics on its migration:generate command. Subclassing is the
+* only way to reach them, and reusing them keeps the generated file byte-identical to
+* the output of `typeorm migration:generate`.
+*/
 var GenerateCommand = class extends MigrationGenerateCommand {
-	static prettify(query) {
-		return this.prettifyQuery(query);
+	static buildStatement(query, parameters, prettify) {
+		const statement = prettify ? this.prettifyQuery(query) : query;
+		return `await queryRunner.query(\`${this.escapeTemplateLiteral(statement)}\`${this.queryParams(parameters)});`;
+	}
+	static buildContent(context, up, down) {
+		const upStatements = up.map((statement) => `        ${statement}`);
+		const downStatements = down.map((statement) => `        ${statement}`);
+		if (context.language === "js") return this.getJavascriptTemplate(context.name, context.timestamp, upStatements, downStatements, context.esm);
+		return this.getTemplate(context.name, context.timestamp, upStatements, downStatements);
 	}
 };
-function queryParams(parameters) {
-	if (!parameters || !parameters.length) return "";
-	return `, ${JSON.stringify(parameters)}`;
-}
-function buildTemplate(name, timestamp, upStatements, downStatements) {
-	const migrationName = `${pascalCase(name)}${timestamp}`;
-	const up = upStatements.map((statement) => `        ${statement}`);
-	const down = downStatements.map((statement) => `        ${statement}`);
-	return `import type { MigrationInterface, QueryRunner } from 'typeorm';
-
-export class ${migrationName} implements MigrationInterface {
-    name = '${migrationName}';
-
-    public async up(queryRunner: QueryRunner): Promise<void> {
-${up.join(`
-`)}
-    }
-    public async down(queryRunner: QueryRunner): Promise<void> {
-${down.join(`
-`)}
-    }
-}
-`;
-}
 async function generateMigration(context) {
-	context.name = context.name || "Default";
-	const timestamp = context.timestamp || (/* @__PURE__ */ new Date()).getTime();
-	const fileName = `${timestamp}-${context.name}.ts`;
-	const { dataSource } = context;
-	const up = [];
-	const down = [];
-	const sqlInMemory = await dataSource.driver.createSchemaBuilder().log();
-	if (context.prettify) {
-		sqlInMemory.upQueries.forEach((upQuery) => {
-			upQuery.query = GenerateCommand.prettify(upQuery.query);
-		});
-		sqlInMemory.downQueries.forEach((downQuery) => {
-			downQuery.query = GenerateCommand.prettify(downQuery.query);
-		});
-	}
-	sqlInMemory.upQueries.forEach((upQuery) => {
-		up.push(`await queryRunner.query(\`${upQuery.query.replace(/`/g, "\\`")}\`${queryParams(upQuery.parameters)});`);
-	});
-	sqlInMemory.downQueries.forEach((downQuery) => {
-		down.push(`await queryRunner.query(\`${downQuery.query.replace(/`/g, "\\`")}\`${queryParams(downQuery.parameters)});`);
-	});
+	const name = context.name || "Default";
+	const timestamp = context.timestamp ?? Date.now();
+	const language = context.language || "ts";
+	const sqlInMemory = await context.dataSource.driver.createSchemaBuilder().log();
+	const up = sqlInMemory.upQueries.map((query) => GenerateCommand.buildStatement(query.query, query.parameters, context.prettify));
+	const down = sqlInMemory.downQueries.map((query) => GenerateCommand.buildStatement(query.query, query.parameters, context.prettify)).reverse();
 	if (up.length === 0 && down.length === 0) return {
 		up,
 		down
 	};
-	const content = buildTemplate(context.name, timestamp, up, down.reverse());
+	const content = GenerateCommand.buildContent({
+		name,
+		timestamp,
+		language,
+		esm: context.esm || false
+	}, up, down);
 	if (!context.preview) {
-		let directoryPath;
-		if (context.directoryPath) if (!path.isAbsolute(context.directoryPath)) directoryPath = path.join(process$1.cwd(), context.directoryPath);
-		else directoryPath = context.directoryPath;
-		else directoryPath = path.join(process$1.cwd(), "migrations");
-		try {
-			await fs.promises.access(directoryPath, fs.constants.R_OK | fs.constants.W_OK);
-		} catch {
-			await fs.promises.mkdir(directoryPath, { recursive: true });
-		}
-		await fs.promises.writeFile(path.join(directoryPath, fileName), content, { encoding: "utf-8" });
+		const directoryPath = resolveFilePath(context.directoryPath || "migrations");
+		await CommandUtils.createFile(path.join(directoryPath, `${timestamp}-${name}.${language}`), content);
 	}
 	return {
 		up,