remult 0.25.8 → 0.26.0

package/migrations/compare-migration-snapshots.js

@@ -0,0 +1,165 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emptySnapshot = exports.compareMigrationSnapshot = void 0;
+var tslib_1 = require("tslib");
+var index_js_1 = require("../index.js");
+var filter_consumer_bridge_to_sql_request_js_1 = require("../src/filter/filter-consumer-bridge-to-sql-request.js");
+function compareMigrationSnapshot(_a) {
+    var entities = _a.entities, snapshot = _a.snapshot, migrationBuilder = _a.migrationBuilder, reporter = _a.reporter;
+    return tslib_1.__awaiter(this, void 0, void 0, function () {
+        var processedEntities, entities_1, entities_1_1, entity, meta, e, entitySnapshot, createColumns, processedColumns, _b, _c, field, columnDbName, column, e_1_1, _d, _e, columnDbName, e_2_1, e_3_1, _f, _g, entityDbName, e_4_1;
+        var e_3, _h, e_1, _j, e_2, _k, e_4, _l;
+        return tslib_1.__generator(this, function (_m) {
+            switch (_m.label) {
+                case 0:
+                    snapshot = JSON.parse(JSON.stringify(snapshot));
+                    processedEntities = new Set();
+                    _m.label = 1;
+                case 1:
+                    _m.trys.push([1, 23, 24, 25]);
+                    entities_1 = tslib_1.__values(entities), entities_1_1 = entities_1.next();
+                    _m.label = 2;
+                case 2:
+                    if (!!entities_1_1.done) return [3 /*break*/, 22];
+                    entity = entities_1_1.value;
+                    meta = (0, index_js_1.repo)(entity).metadata;
+                    return [4 /*yield*/, (0, filter_consumer_bridge_to_sql_request_js_1.dbNamesOf)(meta, function (x) { return x; })];
+                case 3:
+                    e = _m.sent();
+                    processedEntities.add(e.$entityName);
+                    if (!(0, filter_consumer_bridge_to_sql_request_js_1.shouldCreateEntity)(meta, e)) return [3 /*break*/, 21];
+                    entitySnapshot = snapshot.entities[e.$entityName];
+                    createColumns = true;
+                    if (!!entitySnapshot) return [3 /*break*/, 5];
+                    createColumns = false;
+                    reporter('create table ' + e.$entityName);
+                    return [4 /*yield*/, migrationBuilder.createTable(meta)];
+                case 4:
+                    _m.sent();
+                    entitySnapshot = snapshot.entities[e.$entityName] = {
+                        key: meta.key,
+                        className: meta.entityType.name,
+                        columns: {},
+                    };
+                    _m.label = 5;
+                case 5:
+                    processedColumns = new Set();
+                    _m.label = 6;
+                case 6:
+                    _m.trys.push([6, 12, 13, 14]);
+                    _b = (e_1 = void 0, tslib_1.__values(meta.fields)), _c = _b.next();
+                    _m.label = 7;
+                case 7:
+                    if (!!_c.done) return [3 /*break*/, 11];
+                    field = _c.value;
+                    if (!!(0, filter_consumer_bridge_to_sql_request_js_1.shouldNotCreateField)(field, e)) return [3 /*break*/, 10];
+                    columnDbName = e.$dbNameOf(field);
+                    processedColumns.add(columnDbName);
+                    column = entitySnapshot.columns[columnDbName];
+                    if (!!column) return [3 /*break*/, 10];
+                    if (!createColumns) return [3 /*break*/, 9];
+                    reporter('add column ' + e.$entityName + '.' + columnDbName);
+                    return [4 /*yield*/, migrationBuilder.addColumn(meta, field)];
+                case 8:
+                    _m.sent();
+                    _m.label = 9;
+                case 9:
+                    entitySnapshot.columns[columnDbName] = { key: field.key };
+                    _m.label = 10;
+                case 10:
+                    _c = _b.next();
+                    return [3 /*break*/, 7];
+                case 11: return [3 /*break*/, 14];
+                case 12:
+                    e_1_1 = _m.sent();
+                    e_1 = { error: e_1_1 };
+                    return [3 /*break*/, 14];
+                case 13:
+                    try {
+                        if (_c && !_c.done && (_j = _b.return)) _j.call(_b);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                    return [7 /*endfinally*/];
+                case 14:
+                    _m.trys.push([14, 19, 20, 21]);
+                    _d = (e_2 = void 0, tslib_1.__values(Object.keys(entitySnapshot.columns))), _e = _d.next();
+                    _m.label = 15;
+                case 15:
+                    if (!!_e.done) return [3 /*break*/, 18];
+                    columnDbName = _e.value;
+                    if (!!processedColumns.has(columnDbName)) return [3 /*break*/, 17];
+                    reporter('remove column ' + e.$entityName + '.' + columnDbName);
+                    return [4 /*yield*/, migrationBuilder.removeColumn(e.$entityName, columnDbName)];
+                case 16:
+                    _m.sent();
+                    delete entitySnapshot.columns[columnDbName];
+                    _m.label = 17;
+                case 17:
+                    _e = _d.next();
+                    return [3 /*break*/, 15];
+                case 18: return [3 /*break*/, 21];
+                case 19:
+                    e_2_1 = _m.sent();
+                    e_2 = { error: e_2_1 };
+                    return [3 /*break*/, 21];
+                case 20:
+                    try {
+                        if (_e && !_e.done && (_k = _d.return)) _k.call(_d);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                    return [7 /*endfinally*/];
+                case 21:
+                    entities_1_1 = entities_1.next();
+                    return [3 /*break*/, 2];
+                case 22: return [3 /*break*/, 25];
+                case 23:
+                    e_3_1 = _m.sent();
+                    e_3 = { error: e_3_1 };
+                    return [3 /*break*/, 25];
+                case 24:
+                    try {
+                        if (entities_1_1 && !entities_1_1.done && (_h = entities_1.return)) _h.call(entities_1);
+                    }
+                    finally { if (e_3) throw e_3.error; }
+                    return [7 /*endfinally*/];
+                case 25:
+                    _m.trys.push([25, 30, 31, 32]);
+                    _f = tslib_1.__values(Object.keys(snapshot.entities)), _g = _f.next();
+                    _m.label = 26;
+                case 26:
+                    if (!!_g.done) return [3 /*break*/, 29];
+                    entityDbName = _g.value;
+                    if (!!processedEntities.has(entityDbName)) return [3 /*break*/, 28];
+                    reporter('remove table ' + entityDbName);
+                    return [4 /*yield*/, migrationBuilder.removeTable(entityDbName)];
+                case 27:
+                    _m.sent();
+                    delete snapshot.entities[entityDbName];
+                    _m.label = 28;
+                case 28:
+                    _g = _f.next();
+                    return [3 /*break*/, 26];
+                case 29: return [3 /*break*/, 32];
+                case 30:
+                    e_4_1 = _m.sent();
+                    e_4 = { error: e_4_1 };
+                    return [3 /*break*/, 32];
+                case 31:
+                    try {
+                        if (_g && !_g.done && (_l = _f.return)) _l.call(_f);
+                    }
+                    finally { if (e_4) throw e_4.error; }
+                    return [7 /*endfinally*/];
+                case 32: return [2 /*return*/, snapshot];
+            }
+        });
+    });
+}
+exports.compareMigrationSnapshot = compareMigrationSnapshot;
+function emptySnapshot() {
+    return {
+        version: 1,
+        entities: {},
+    };
+}
+exports.emptySnapshot = emptySnapshot;

package/migrations/generate-migrations.d.ts

@@ -0,0 +1,21 @@
+import type { DataProvider } from '../index.js';
+/**
+ * Generates migration scripts based on changes in entities.
+ *
+ * @param options - Configuration options for generating migrations.
+ * @param options.entities - An array of entity classes whose changes will be included in the migration.
+ * @param options.dataProvider - The data provider instance or a function returning a promise of the data provider.
+ * @param options.migrationsFolder - (Optional) The path to the folder where migration scripts will be stored. Default is 'src/migrations'.
+ * @param options.snapshotFile - (Optional) The path to the file where the snapshot of the last known state will be stored. Default is 'migrations-snapshot.json' in the `migrationsFolder`.
+ * @param options.migrationsTSFile - (Optional) The path to the TypeScript file where the generated migrations will be written. Default is 'migrations.ts' in the `migrationsFolder`.
+ * @param options.endConnection - (Optional) Determines whether to close the database connection after generating migrations. Default is false.
+ * @see [Migrations](https://remult.dev/docs/migrations.html)
+ */
+export declare function generateMigrations(options: {
+    entities: any[];
+    dataProvider: DataProvider | Promise<DataProvider> | (() => Promise<DataProvider | undefined>);
+    migrationsFolder?: string;
+    snapshotFile?: string;
+    migrationsTSFile?: string;
+    endConnection?: boolean;
+}): Promise<boolean>;

package/migrations/generate-migrations.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateMigrations = void 0;
+var tslib_1 = require("tslib");
+var path_1 = tslib_1.__importDefault(require("path"));
+var fs_1 = tslib_1.__importDefault(require("fs"));
+var compare_migration_snapshots_js_1 = require("./compare-migration-snapshots.js");
+var update_migrations_ts_file_js_1 = require("./update-migrations-ts-file.js");
+var migration_types_js_1 = require("./migration-types.js");
+var isOfType_js_1 = require("../src/isOfType.js");
+var initDataProvider_js_1 = require("../server/initDataProvider.js");
+/**
+ * Generates migration scripts based on changes in entities.
+ *
+ * @param options - Configuration options for generating migrations.
+ * @param options.entities - An array of entity classes whose changes will be included in the migration.
+ * @param options.dataProvider - The data provider instance or a function returning a promise of the data provider.
+ * @param options.migrationsFolder - (Optional) The path to the folder where migration scripts will be stored. Default is 'src/migrations'.
+ * @param options.snapshotFile - (Optional) The path to the file where the snapshot of the last known state will be stored. Default is 'migrations-snapshot.json' in the `migrationsFolder`.
+ * @param options.migrationsTSFile - (Optional) The path to the TypeScript file where the generated migrations will be written. Default is 'migrations.ts' in the `migrationsFolder`.
+ * @param options.endConnection - (Optional) Determines whether to close the database connection after generating migrations. Default is false.
+ * @see [Migrations](https://remult.dev/docs/migrations.html)
+ */
+function generateMigrations(options) {
+    return tslib_1.__awaiter(this, void 0, void 0, function () {
+        var migrationDir, snapshotFileName, migrationsTSFilename, dataProvider, _a, _b, p, snapshot, hasSql, steps, code, migrationBuilder, reporter;
+        var e_1, _c;
+        return tslib_1.__generator(this, function (_d) {
+            switch (_d.label) {
+                case 0:
+                    migrationDir = options.migrationsFolder || path_1.default.join(process.cwd(), 'src/migrations');
+                    snapshotFileName = options.snapshotFile || path_1.default.join(migrationDir, 'migrations-snapshot.json');
+                    migrationsTSFilename = options.migrationsTSFile || path_1.default.join(migrationDir, 'migrations.ts');
+                    return [4 /*yield*/, (0, initDataProvider_js_1.initDataProvider)(options.dataProvider)];
+                case 1:
+                    dataProvider = _d.sent();
+                    try {
+                        for (_a = tslib_1.__values([snapshotFileName, migrationsTSFilename]), _b = _a.next(); !_b.done; _b = _a.next()) {
+                            p = _b.value;
+                            if (!fs_1.default.existsSync(path_1.default.dirname(p))) {
+                                fs_1.default.mkdirSync(path_1.default.dirname(p), { recursive: true });
+                            }
+                        }
+                    }
+                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                    finally {
+                        try {
+                            if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                    }
+                    snapshot = (0, compare_migration_snapshots_js_1.emptySnapshot)();
+                    if (fs_1.default.existsSync(snapshotFileName)) {
+                        snapshot = JSON.parse(fs_1.default.readFileSync(snapshotFileName).toString());
+                    }
+                    hasSql = false;
+                    steps = [];
+                    code = {
+                        //https://marketplace.visualstudio.com/items?itemName=qufiwefefwoyn.inline-sql-syntax
+                        addSql: function (sql) {
+                            steps.push('await sql(`--sql\n' + sql + '`)');
+                            hasSql = true;
+                        },
+                        addTypescriptCode: function (code) { return steps.push(code); },
+                        addComment: function (comment) {
+                            return steps.push(comment.indexOf('\n') >= 0 ? "/*".concat(comment, "*/") : "// ".concat(comment));
+                        },
+                    };
+                    migrationBuilder = new migration_types_js_1.DefaultMigrationBuilder(code);
+                    if ((0, isOfType_js_1.isOfType)(dataProvider, 'provideMigrationBuilder')) {
+                        migrationBuilder = new migration_types_js_1.DefaultMigrationBuilder(code, dataProvider.provideMigrationBuilder(code));
+                    }
+                    reporter = function (what) { return console.log('[generateMigrations] ' + what); };
+                    return [4 /*yield*/, (0, compare_migration_snapshots_js_1.compareMigrationSnapshot)({
+                            entities: options.entities,
+                            snapshot: snapshot,
+                            reporter: reporter,
+                            migrationBuilder: migrationBuilder,
+                        })];
+                case 2:
+                    snapshot = _d.sent();
+                    if (!steps.length) return [3 /*break*/, 4];
+                    return [4 /*yield*/, (0, update_migrations_ts_file_js_1.updateMigrationsFile)(migrationsTSFilename, [
+                            "async (".concat(hasSql ? '{sql}' : '', ")=>{\n").concat(steps.join('\n'), "\n}"),
+                        ])];
+                case 3:
+                    _d.sent();
+                    return [3 /*break*/, 5];
+                case 4:
+                    reporter('No changes detected');
+                    _d.label = 5;
+                case 5:
+                    fs_1.default.writeFileSync(snapshotFileName, JSON.stringify(snapshot, null, 2));
+                    if (!(options.endConnection && (0, isOfType_js_1.isOfType)(dataProvider, 'end'))) return [3 /*break*/, 7];
+                    return [4 /*yield*/, dataProvider.end()];
+                case 6:
+                    _d.sent();
+                    _d.label = 7;
+                case 7: return [2 /*return*/, steps.length > 0];
+            }
+        });
+    });
+}
+exports.generateMigrations = generateMigrations;

package/migrations/index.d.ts

@@ -0,0 +1,3 @@
+export { Migrations, MigrationUtils } from './migration-types.js';
+export { generateMigrations } from './generate-migrations.js';
+export { migrate } from './migrate.js';

package/migrations/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.migrate = exports.generateMigrations = void 0;
+var generate_migrations_js_1 = require("./generate-migrations.js");
+Object.defineProperty(exports, "generateMigrations", { enumerable: true, get: function () { return generate_migrations_js_1.generateMigrations; } });
+var migrate_js_1 = require("./migrate.js");
+Object.defineProperty(exports, "migrate", { enumerable: true, get: function () { return migrate_js_1.migrate; } });

package/migrations/migrate.d.ts

@@ -0,0 +1,27 @@
+import { type DataProvider } from '../index.js';
+import type { Migrations } from './migration-types.js';
+/**
+ * Applies migration scripts to update the database schema.
+ *
+ * @param options - Configuration options for applying migrations.
+ * @param options.migrations - An object containing the migration scripts, each keyed by a unique identifier.
+ * @param options.dataProvider - The data provider instance or a function returning a promise of the data provider.
+ * @param options.migrationsTable - (Optional) The name of the table that tracks applied migrations. Default is '__remult_migrations_version'.
+ * @param options.endConnection - (Optional) Determines whether to close the database connection after applying migrations. Default is false.
+ * @param options.beforeMigration - (Optional) A callback function that is called before each migration is applied. Receives an object with the migration index.
+ * @param options.afterMigration - (Optional) A callback function that is called after each migration is applied. Receives an object with the migration index and the duration of the migration.
+ * @see [Migrations](https://remult.dev/docs/migrations.html)
+ */
+export declare function migrate(options: {
+    migrations: Migrations;
+    dataProvider: DataProvider | Promise<DataProvider> | (() => Promise<DataProvider | undefined>);
+    migrationsTable?: string;
+    endConnection?: boolean;
+    beforeMigration?: (info: {
+        index: number;
+    }) => void | Promise<void>;
+    afterMigration?: (info: {
+        index: number;
+        duration: number;
+    }) => void | Promise<void>;
+}): Promise<void>;

package/migrations/migrate.js

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.migrate = void 0;
+var tslib_1 = require("tslib");
+var index_js_1 = require("../index.js");
+var initDataProvider_js_1 = require("../server/initDataProvider.js");
+var context_js_1 = require("../src/context.js");
+var isOfType_js_1 = require("../src/isOfType.js");
+/**
+ * Applies migration scripts to update the database schema.
+ *
+ * @param options - Configuration options for applying migrations.
+ * @param options.migrations - An object containing the migration scripts, each keyed by a unique identifier.
+ * @param options.dataProvider - The data provider instance or a function returning a promise of the data provider.
+ * @param options.migrationsTable - (Optional) The name of the table that tracks applied migrations. Default is '__remult_migrations_version'.
+ * @param options.endConnection - (Optional) Determines whether to close the database connection after applying migrations. Default is false.
+ * @param options.beforeMigration - (Optional) A callback function that is called before each migration is applied. Receives an object with the migration index.
+ * @param options.afterMigration - (Optional) A callback function that is called after each migration is applied. Receives an object with the migration index and the duration of the migration.
+ * @see [Migrations](https://remult.dev/docs/migrations.html)
+ */
+function migrate(options) {
+    return tslib_1.__awaiter(this, void 0, void 0, function () {
+        var migrationTableName, dataProvider, prev, VersionInfo_1, steps_1;
+        var _this = this;
+        return tslib_1.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    migrationTableName = options.migrationsTable || '__remult_migrations_version';
+                    return [4 /*yield*/, (0, initDataProvider_js_1.initDataProvider)(options.dataProvider)];
+                case 1:
+                    dataProvider = _a.sent();
+                    prev = index_js_1.remult.dataProvider;
+                    index_js_1.remult.dataProvider = dataProvider;
+                    _a.label = 2;
+                case 2:
+                    _a.trys.push([2, , 6, 7]);
+                    VersionInfo_1 = /** @class */ (function (_super) {
+                        tslib_1.__extends(VersionInfo, _super);
+                        function VersionInfo() {
+                            var _this = _super !== null && _super.apply(this, arguments) || this;
+                            _this.version = -1;
+                            return _this;
+                        }
+                        tslib_1.__decorate([
+                            index_js_1.Fields.number(),
+                            tslib_1.__metadata("design:type", Object)
+                        ], VersionInfo_1.prototype, "version", void 0);
+                        VersionInfo = tslib_1.__decorate([
+                            (0, index_js_1.Entity)(migrationTableName)
+                        ], VersionInfo);
+                        return VersionInfo;
+                    }(index_js_1.IdEntity));
+                    steps_1 = Object.entries(options.migrations).sort(function (_a, _b) {
+                        var _c = tslib_1.__read(_a, 1), a = _c[0];
+                        var _d = tslib_1.__read(_b, 1), b = _d[0];
+                        return parseInt(a) - parseInt(b);
+                    });
+                    if (!dataProvider.ensureSchema) return [3 /*break*/, 4];
+                    return [4 /*yield*/, dataProvider.ensureSchema([
+                            new index_js_1.Remult(dataProvider).repo(VersionInfo_1).metadata,
+                        ])];
+                case 3:
+                    _a.sent();
+                    _a.label = 4;
+                case 4: return [4 /*yield*/, (0, context_js_1.doTransaction)(index_js_1.remult, function (dp) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                        var repo, v, steps_2, steps_2_1, _a, stepText, action, step, startTime, utils, err_1, e_1_1;
+                        var e_1, _b;
+                        var _this = this;
+                        return tslib_1.__generator(this, function (_c) {
+                            switch (_c.label) {
+                                case 0:
+                                    repo = new index_js_1.Remult(dataProvider).repo(VersionInfo_1, dp);
+                                    return [4 /*yield*/, repo.findFirst()];
+                                case 1:
+                                    v = _c.sent();
+                                    if (!v) {
+                                        v = repo.create();
+                                        v.version = -1;
+                                    }
+                                    _c.label = 2;
+                                case 2:
+                                    _c.trys.push([2, 15, 16, 17]);
+                                    steps_2 = tslib_1.__values(steps_1), steps_2_1 = steps_2.next();
+                                    _c.label = 3;
+                                case 3:
+                                    if (!!steps_2_1.done) return [3 /*break*/, 14];
+                                    _a = tslib_1.__read(steps_2_1.value, 2), stepText = _a[0], action = _a[1];
+                                    step = parseInt(stepText);
+                                    if (step < 0)
+                                        throw new Error('Migration step number must be a non-negative integer');
+                                    if (v.version >= step)
+                                        return [3 /*break*/, 13];
+                                    if (!options.beforeMigration) return [3 /*break*/, 5];
+                                    return [4 /*yield*/, options.beforeMigration({ index: step })];
+                                case 4:
+                                    _c.sent();
+                                    _c.label = 5;
+                                case 5:
+                                    startTime = Date.now();
+                                    console.info('Executing migration step ' + step);
+                                    console.time('Completed migration step ' + step);
+                                    _c.label = 6;
+                                case 6:
+                                    _c.trys.push([6, 10, , 11]);
+                                    utils = {
+                                        sql: function (sql) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                                            return tslib_1.__generator(this, function (_a) {
+                                                switch (_a.label) {
+                                                    case 0: return [4 /*yield*/, (0, isOfType_js_1.cast)(dp, 'execute').execute(sql)];
+                                                    case 1: return [2 /*return*/, _a.sent()];
+                                                }
+                                            });
+                                        }); },
+                                    };
+                                    return [4 /*yield*/, action(utils)];
+                                case 7:
+                                    _c.sent();
+                                    if (!options.afterMigration) return [3 /*break*/, 9];
+                                    return [4 /*yield*/, options.afterMigration({
+                                            index: step,
+                                            duration: Date.now() - startTime,
+                                        })];
+                                case 8:
+                                    _c.sent();
+                                    _c.label = 9;
+                                case 9:
+                                    console.timeEnd('Completed migration step ' + step);
+                                    return [3 /*break*/, 11];
+                                case 10:
+                                    err_1 = _c.sent();
+                                    console.error('Failed to execute migration step ' + step);
+                                    console.error(err_1);
+                                    throw err_1;
+                                case 11:
+                                    v.version = step;
+                                    return [4 /*yield*/, v.save()];
+                                case 12:
+                                    _c.sent();
+                                    _c.label = 13;
+                                case 13:
+                                    steps_2_1 = steps_2.next();
+                                    return [3 /*break*/, 3];
+                                case 14: return [3 /*break*/, 17];
+                                case 15:
+                                    e_1_1 = _c.sent();
+                                    e_1 = { error: e_1_1 };
+                                    return [3 /*break*/, 17];
+                                case 16:
+                                    try {
+                                        if (steps_2_1 && !steps_2_1.done && (_b = steps_2.return)) _b.call(steps_2);
+                                    }
+                                    finally { if (e_1) throw e_1.error; }
+                                    return [7 /*endfinally*/];
+                                case 17: return [2 /*return*/];
+                            }
+                        });
+                    }); })];
+                case 5:
+                    _a.sent();
+                    return [3 /*break*/, 7];
+                case 6:
+                    index_js_1.remult.dataProvider = prev;
+                    return [7 /*endfinally*/];
+                case 7:
+                    if (!(options.endConnection && (0, isOfType_js_1.isOfType)(dataProvider, 'end'))) return [3 /*break*/, 9];
+                    return [4 /*yield*/, dataProvider.end()];
+                case 8:
+                    _a.sent();
+                    _a.label = 9;
+                case 9: return [2 /*return*/];
+            }
+        });
+    });
+}
+exports.migrate = migrate;

package/migrations/migration-types.d.ts

@@ -0,0 +1,48 @@
+import type { EntityMetadata, FieldMetadata } from '../index.js';
+export interface CanBuildMigrations {
+    provideMigrationBuilder(builder: MigrationCode): MigrationBuilder;
+}
+export interface MigrationBuilder {
+    createTable(meta: EntityMetadata): Promise<void>;
+    addColumn(meta: EntityMetadata, field: FieldMetadata): Promise<void>;
+    removeTable?(entityDbName: string): unknown;
+    removeColumn?($entityName: string, columnDbName: string): unknown;
+}
+export interface MigrationCode {
+    addSql(sql: string): void;
+    addComment(comment: string): void;
+    addTypescriptCode(code: string): void;
+}
+/**
+ * Represents a set of migrations, each identified by a unique number.
+ *
+ * Each migration function takes a `MigrationUtils` object as a parameter, which provides utility methods for executing SQL statements and other migration-related operations.
+ *
+ * Migrations are executed in a transaction, meaning that all changes within a single migration are either fully applied or fully rolled back in case of an error. This ensures the consistency of the database state.
+ *
+ * Note: Some databases, like MySQL, do not support rolling back structural changes (e.g., table creation or alteration) as part of a transaction. Developers should be aware of this when designing migrations for such databases.
+ *
+ * @example
+ * export const migrations: Migrations = {
+ *   1: async ({ sql }) => {
+ *     await sql(`CREATE TABLE example (id SERIAL PRIMARY KEY, name VARCHAR(255))`);
+ *   },
+ *   2: async ({ sql }) => {
+ *     await sql(`ALTER TABLE example ADD COLUMN description TEXT`);
+ *   },
+ * };
+ * @see [Migrations](http://remult.dev/docs/migrations.html)
+ */
+export type Migrations = Record<number, (utils: MigrationUtils) => Promise<unknown>>;
+export type MigrationUtils = {
+    sql(sql: string): Promise<unknown>;
+};
+export declare class DefaultMigrationBuilder implements Required<MigrationBuilder> {
+    code: MigrationCode;
+    private wrapped?;
+    constructor(code: MigrationCode, wrapped?: MigrationBuilder);
+    createTable(meta: EntityMetadata): Promise<void>;
+    addColumn(meta: EntityMetadata, field: FieldMetadata): Promise<void>;
+    removeTable(entityDbName: string): Promise<void>;
+    removeColumn(entityName: string, columnDbName: string): Promise<void>;
+}

package/migrations/migration-types.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultMigrationBuilder = void 0;
+var tslib_1 = require("tslib");
+var DefaultMigrationBuilder = /** @class */ (function () {
+    function DefaultMigrationBuilder(code, wrapped) {
+        this.code = code;
+        this.wrapped = wrapped;
+    }
+    DefaultMigrationBuilder.prototype.createTable = function (meta) {
+        var _a;
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!((_a = this.wrapped) === null || _a === void 0 ? void 0 : _a.createTable)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.wrapped.createTable(meta)];
+                    case 1:
+                        _b.sent();
+                        return [3 /*break*/, 3];
+                    case 2:
+                        this.code.addComment('TODO: implement create table ' + meta.dbName);
+                        _b.label = 3;
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    DefaultMigrationBuilder.prototype.addColumn = function (meta, field) {
+        var _a;
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!((_a = this.wrapped) === null || _a === void 0 ? void 0 : _a.addColumn)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.wrapped.addColumn(meta, field)];
+                    case 1:
+                        _b.sent();
+                        return [3 /*break*/, 3];
+                    case 2:
+                        this.code.addComment('TODO: implement add column ' + meta.dbName + '.' + field.dbName);
+                        _b.label = 3;
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    DefaultMigrationBuilder.prototype.removeTable = function (entityDbName) {
+        var _a;
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!((_a = this.wrapped) === null || _a === void 0 ? void 0 : _a.removeTable)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.wrapped.removeTable(entityDbName)];
+                    case 1:
+                        _b.sent();
+                        return [3 /*break*/, 3];
+                    case 2:
+                        this.code.addComment('TODO: implement remove table ' + entityDbName);
+                        _b.label = 3;
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    DefaultMigrationBuilder.prototype.removeColumn = function (entityName, columnDbName) {
+        var _a;
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!((_a = this.wrapped) === null || _a === void 0 ? void 0 : _a.removeColumn)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.wrapped.removeColumn(entityName, columnDbName)];
+                    case 1:
+                        _b.sent();
+                        return [3 /*break*/, 3];
+                    case 2:
+                        this.code.addComment('TODO: implement remove column ' + entityName + '.' + columnDbName);
+                        _b.label = 3;
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return DefaultMigrationBuilder;
+}());
+exports.DefaultMigrationBuilder = DefaultMigrationBuilder;

package/migrations/update-migrations-ts-file.d.ts

@@ -0,0 +1 @@
+export declare function updateMigrationsFile(filePath: string, steps: string[]): Promise<void>;