remult 0.25.7 → 0.25.8-exp.0

package/esm/src/data-providers/sql-database.js

@@ -6,14 +6,16 @@ import { getRepository } from '../remult3/RepositoryImplementation.js';
 import { Sort } from '../sort.js';
 import { ValueConverters } from '../valueConverters.js';
 import { getRepositoryInternals } from '../remult3/repository-internals.js';
+import { isOfType } from '../isOfType.js';
 // @dynamic
 export class SqlDatabase {
     sql;
     static getDb(remult) {
         const r = (remult || defaultRemult).dataProvider;
-        if (!r.createCommand)
-            throw 'the data provider is not an SqlDatabase';
-        return r;
+        if (isOfType(r, 'createCommand'))
+            return r;
+        else
+            throw 'the data provider is not an SqlCommandFactory';
     }
     createCommand() {
         return new LogSQLCommand(this.sql.createCommand(), SqlDatabase.LogToConsole);
@@ -116,7 +118,12 @@ export class SqlDatabase {
         this.sql = sql;
         if (sql.wrapIdentifier)
             this.wrapIdentifier = (x) => sql.wrapIdentifier(x);
+        if (isOfType(sql, 'provideMigrationBuilder')) {
+            this.provideMigrationBuilder = sql.provideMigrationBuilder;
+        }
     }
+    provideMigrationBuilder;
+    isProxy;
     createdEntities = [];
 }
 const icons = new Map([

package/esm/src/filter/filter-consumer-bridge-to-sql-request.js

@@ -164,6 +164,10 @@ export function shouldNotCreateField(field, dbNames) {
     return (field.isServerExpression ||
         (field.options.sqlExpression && field.dbName != dbNames.$dbNameOf(field)));
 }
+export function shouldCreateEntity(entity, e) {
+    return (!entity.options.sqlExpression &&
+        e.$entityName.toLowerCase().indexOf('from ') < 0);
+}
 export async function dbNamesOf(repo, wrapIdentifierOrOptions) {
     let options = typeof wrapIdentifierOrOptions === 'function'
         ? { wrapIdentifier: wrapIdentifierOrOptions }

package/esm/src/isOfType.js

@@ -0,0 +1,9 @@
+export function isOfType(obj, checkMethod) {
+    return typeof obj[checkMethod] === 'function';
+}
+export function cast(obj, checkMethod) {
+    if (isOfType(obj, checkMethod)) {
+        return obj;
+    }
+    throw new Error(`Object is not of type ${checkMethod.toString()}`);
+}

package/esm/src/remult3/remult3.js

@@ -1,22 +1,30 @@
 export {};
-/*y1 - workshop
-
-* Experiment with doing this with version control - so the students can follow changes
-* Prepare stackblitz
-
+//p1 - migrations - in docs empesize that mysql doesn't support transactions in ddl, in docs empesize destroy for knex - // await dataProvider.knex.destroy()
+//https://gitkraken.dev/link/dnNjb2RlOi8vZWFtb2Rpby5naXRsZW5zL2xpbmsvci9mMDgzMWU0OWIyODJkMDlkNTA0NTcxYjYwNmUzNTMwODQ3NGIwY2M2L2YvcHJvamVjdHMvcGxheS13aXRoLW1pZ3JhdGlvbnMvc3JjL3NlcnZlci9idWlsZC1taWdyYXRpb25zLnRzP3VybD1odHRwcyUzQSUyRiUyRmdpdGh1Yi5jb20lMkZyZW11bHQlMkZyZW11bHQuZ2l0?origin=gitlens
+/*p1 - processError in remult express
+- Should we merge (notFound,error,forbidden) into one method in `DataApiResponse` type?
+https://gitkraken.dev/link/dnNjb2RlOi8vZWFtb2Rpby5naXRsZW5zL2xpbmsvci9mMDgzMWU0OWIyODJkMDlkNTA0NTcxYjYwNmUzNTMwODQ3NGIwY2M2L2YvcHJvamVjdHMvY29yZS9zcmMvZGF0YS1hcGkudHM%2FdXJsPWh0dHBzJTNBJTJGJTJGZ2l0aHViLmNvbSUyRnJlbXVsdCUyRnJlbXVsdC5naXQ%3D?origin=gitlens
+- The api of the `processError` should recieve an `ErrorInfo` object and return an `ErrorInfo` object? or should it return something more in the line,
+of httpStatus and errorBody. - currently the `serializeError` method is used to build the response
+https://gitkraken.dev/link/dnNjb2RlOi8vZWFtb2Rpby5naXRsZW5zL2xpbmsvci9mMDgzMWU0OWIyODJkMDlkNTA0NTcxYjYwNmUzNTMwODQ3NGIwY2M2L2YvcHJvamVjdHMvY29yZS9zcmMvZGF0YS1hcGkudHM%2FdXJsPWh0dHBzJTNBJTJGJTJGZ2l0aHViLmNvbSUyRnJlbXVsdCUyRnJlbXVsdC5naXQmbGluZXM9NDI1?origin=gitlens
+- I think there should be a way to throw a forbidden exception
+*/
+//p1 - cleanup root directory of reult
+//p1 - in this video I'll use remult to turn a frontend app to a fullstack app
+/*y1 - discuss using delete & put - with url query language for deleteMany and updateMany -
+  - put & delete, similar to get
+  - add where to count, deleteMany,updateMany,
+  - prevent delete all and update all - must have meaningful where.
+    - try forcing this also in typescript
 
-# influencer:
-  * review react summit
-#
+  - protect against deleting of all rows by mistake
+  - https://github.com/remult/remult/issues/221#issuecomment-2016519746
 
+*/
 //y1 - getFields didn't work for kobi in the home component
-
-//p1 - processError in remult express
-//p1 - I think there should be a way to throw a forbidden exception
 //p1 - add section to Fields doc, explaining field type in db
 //p1 - add section about union type
 //p1 - add section about value list field type
-
 /*y1 - Talk JYC - JYC - add some integrity checks on delete
   - soft delete
   - delete restrict (implicit, or user selected - and if so, how) (delete & update of id)
@@ -53,7 +61,6 @@ export class Currency {
 //y1 - I think that the tests you've setup don't cover next app router - I added to the setup, but not sure where else
 //y1 - talk about the parameter issue with backend methods
 //y1 - select data provider per entity https://discord.com/channels/975754286384418847/976006081748807690/1201415305885397003
-//y1 - migrations
 //y1 - live query refresh of view on table update
 //y1 - main vs master
 //y2 - livequery for findfirst (@JY)

package/migrations/compare-migration-snapshots.d.ts

@@ -0,0 +1,26 @@
+import type { MigrationBuilder } from './migration-types.js';
+export declare function compareMigrationSnapshot({ entities, snapshot, migrationBuilder: migrationBuilder, }: {
+    entities: any[];
+    snapshot: EntitiesSnapshot;
+    migrationBuilder: MigrationBuilder;
+}): Promise<{
+    version: number;
+    entities: Record<string, {
+        key: string;
+        className: string;
+        columns: Record<string, {
+            key: string;
+        }>;
+    }>;
+}>;
+export declare function emptySnapshot(): {
+    version: number;
+    entities: Record<string, {
+        key: string;
+        className: string;
+        columns: Record<string, {
+            key: string;
+        }>;
+    }>;
+};
+export type EntitiesSnapshot = ReturnType<typeof emptySnapshot>;

package/migrations/compare-migration-snapshots.js

@@ -0,0 +1,101 @@
+"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;
+    return tslib_1.__awaiter(this, void 0, void 0, function () {
+        var entities_1, entities_1_1, entity, meta, e, entitySnapshot, createColumns, _b, _c, field, column, e_1_1, e_2_1;
+        var e_2, _d, e_1, _e;
+        return tslib_1.__generator(this, function (_f) {
+            switch (_f.label) {
+                case 0:
+                    snapshot = JSON.parse(JSON.stringify(snapshot));
+                    _f.label = 1;
+                case 1:
+                    _f.trys.push([1, 16, 17, 18]);
+                    entities_1 = tslib_1.__values(entities), entities_1_1 = entities_1.next();
+                    _f.label = 2;
+                case 2:
+                    if (!!entities_1_1.done) return [3 /*break*/, 15];
+                    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 = _f.sent();
+                    if (!(0, filter_consumer_bridge_to_sql_request_js_1.shouldCreateEntity)(meta, e)) return [3 /*break*/, 13];
+                    entitySnapshot = snapshot.entities[e.$entityName];
+                    createColumns = true;
+                    if (!!entitySnapshot) return [3 /*break*/, 5];
+                    createColumns = false;
+                    return [4 /*yield*/, migrationBuilder.createTable(meta)];
+                case 4:
+                    _f.sent();
+                    entitySnapshot = snapshot.entities[e.$entityName] = {
+                        key: meta.key,
+                        className: meta.entityType.name,
+                        columns: {},
+                    };
+                    _f.label = 5;
+                case 5:
+                    _f.trys.push([5, 11, 12, 13]);
+                    _b = (e_1 = void 0, tslib_1.__values(meta.fields)), _c = _b.next();
+                    _f.label = 6;
+                case 6:
+                    if (!!_c.done) return [3 /*break*/, 10];
+                    field = _c.value;
+                    if (!!(0, filter_consumer_bridge_to_sql_request_js_1.shouldNotCreateField)(field, e)) return [3 /*break*/, 9];
+                    column = entitySnapshot.columns[e.$dbNameOf(field)];
+                    if (!!column) return [3 /*break*/, 9];
+                    if (!createColumns) return [3 /*break*/, 8];
+                    return [4 /*yield*/, migrationBuilder.addColumn(meta, field)];
+                case 7:
+                    _f.sent();
+                    _f.label = 8;
+                case 8:
+                    entitySnapshot.columns[e.$dbNameOf(field)] = { key: field.key };
+                    _f.label = 9;
+                case 9:
+                    _c = _b.next();
+                    return [3 /*break*/, 6];
+                case 10: return [3 /*break*/, 13];
+                case 11:
+                    e_1_1 = _f.sent();
+                    e_1 = { error: e_1_1 };
+                    return [3 /*break*/, 13];
+                case 12:
+                    try {
+                        if (_c && !_c.done && (_e = _b.return)) _e.call(_b);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                    return [7 /*endfinally*/];
+                case 13: return [2 /*return*/, snapshot];
+                case 14:
+                    entities_1_1 = entities_1.next();
+                    return [3 /*break*/, 2];
+                case 15: return [3 /*break*/, 18];
+                case 16:
+                    e_2_1 = _f.sent();
+                    e_2 = { error: e_2_1 };
+                    return [3 /*break*/, 18];
+                case 17:
+                    try {
+                        if (entities_1_1 && !entities_1_1.done && (_d = entities_1.return)) _d.call(entities_1);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                    return [7 /*endfinally*/];
+                case 18: return [2 /*return*/];
+            }
+        });
+    });
+}
+exports.compareMigrationSnapshot = compareMigrationSnapshot;
+function emptySnapshot() {
+    return {
+        version: 1,
+        entities: {},
+    };
+}
+exports.emptySnapshot = emptySnapshot;

package/migrations/generate-migrations.d.ts

@@ -0,0 +1,8 @@
+import type { DataProvider } from '../index.js';
+export declare function generateMigrations(options: {
+    entities: any[];
+    dataProvider: Promise<DataProvider> | DataProvider;
+    migrationsDir?: string;
+    snapshotFileName?: string;
+    migrationsTSFilename?: string;
+}): Promise<void>;

package/migrations/generate-migrations.js

@@ -0,0 +1,82 @@
+"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");
+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;
+        var e_1, _c;
+        return tslib_1.__generator(this, function (_d) {
+            switch (_d.label) {
+                case 0:
+                    migrationDir = options.migrationsDir || path_1.default.join(process.cwd(), 'src/server/migrations');
+                    snapshotFileName = options.snapshotFileName ||
+                        path_1.default.join(migrationDir, 'migrations-snapshot.json');
+                    migrationsTSFilename = options.migrationsTSFilename || path_1.default.join(migrationDir, 'migrations.ts');
+                    return [4 /*yield*/, 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 = dataProvider.provideMigrationBuilder(code);
+                    }
+                    return [4 /*yield*/, (0, compare_migration_snapshots_js_1.compareMigrationSnapshot)({
+                            entities: options.entities,
+                            snapshot: snapshot,
+                            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();
+                    _d.label = 4;
+                case 4:
+                    fs_1.default.writeFileSync(snapshotFileName, JSON.stringify(snapshot, null, 2));
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+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,7 @@
+import { type DataProvider } from '../index.js';
+import type { Migrations } from './migration-types.js';
+export declare function migrate(options: {
+    migrations: Migrations;
+    dataProvider?: Promise<DataProvider> | DataProvider;
+    migrationTableName?: string;
+}): Promise<void>;

package/migrations/migrate.js

@@ -0,0 +1,147 @@
+"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 context_js_1 = require("../src/context.js");
+var isOfType_js_1 = require("../src/isOfType.js");
+function migrate(options) {
+    return tslib_1.__awaiter(this, void 0, void 0, function () {
+        var migrationTableName, dataProvider, _a, prev, VersionInfo, repo, v, steps, _loop_1, steps_1, steps_1_1, _b, stepText, action, e_1_1;
+        var e_1, _c;
+        var _this = this;
+        return tslib_1.__generator(this, function (_d) {
+            switch (_d.label) {
+                case 0:
+                    migrationTableName = options.migrationTableName || '__remult_migration_version';
+                    if (!options.dataProvider) return [3 /*break*/, 2];
+                    return [4 /*yield*/, options.dataProvider];
+                case 1:
+                    _a = _d.sent();
+                    return [3 /*break*/, 3];
+                case 2:
+                    _a = index_js_1.remult.dataProvider;
+                    _d.label = 3;
+                case 3:
+                    dataProvider = _a;
+                    prev = index_js_1.remult.dataProvider;
+                    index_js_1.remult.dataProvider = dataProvider;
+                    _d.label = 4;
+                case 4:
+                    _d.trys.push([4, , 16, 17]);
+                    VersionInfo = /** @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.prototype, "version", void 0);
+                        VersionInfo = tslib_1.__decorate([
+                            (0, index_js_1.Entity)(migrationTableName)
+                        ], VersionInfo);
+                        return VersionInfo;
+                    }(index_js_1.IdEntity));
+                    repo = new index_js_1.Remult(dataProvider).repo(VersionInfo);
+                    if (!dataProvider.ensureSchema) return [3 /*break*/, 6];
+                    return [4 /*yield*/, dataProvider.ensureSchema([repo.metadata])];
+                case 5:
+                    _d.sent();
+                    _d.label = 6;
+                case 6: return [4 /*yield*/, repo.findFirst()];
+                case 7:
+                    v = _d.sent();
+                    if (!v) {
+                        v = repo.create();
+                        v.version = -1;
+                    }
+                    steps = 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);
+                    });
+                    _loop_1 = function (stepText, action) {
+                        var step;
+                        return tslib_1.__generator(this, function (_e) {
+                            switch (_e.label) {
+                                case 0:
+                                    step = parseInt(stepText);
+                                    if (step < 0)
+                                        throw new Error('Migration step number must be a non-negative integer');
+                                    if (v.version >= step)
+                                        return [2 /*return*/, "continue"];
+                                    console.info('Executing migration step', step);
+                                    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 utils;
+                                            var _this = this;
+                                            return tslib_1.__generator(this, function (_a) {
+                                                switch (_a.label) {
+                                                    case 0:
+                                                        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:
+                                                                            _a.sent();
+                                                                            return [2 /*return*/];
+                                                                    }
+                                                                });
+                                                            }); },
+                                                        };
+                                                        return [4 /*yield*/, action(utils)];
+                                                    case 1:
+                                                        _a.sent();
+                                                        return [2 /*return*/];
+                                                }
+                                            });
+                                        }); })];
+                                case 1:
+                                    _e.sent();
+                                    v.version = step;
+                                    return [4 /*yield*/, v.save()];
+                                case 2:
+                                    _e.sent();
+                                    return [2 /*return*/];
+                            }
+                        });
+                    };
+                    _d.label = 8;
+                case 8:
+                    _d.trys.push([8, 13, 14, 15]);
+                    steps_1 = tslib_1.__values(steps), steps_1_1 = steps_1.next();
+                    _d.label = 9;
+                case 9:
+                    if (!!steps_1_1.done) return [3 /*break*/, 12];
+                    _b = tslib_1.__read(steps_1_1.value, 2), stepText = _b[0], action = _b[1];
+                    return [5 /*yield**/, _loop_1(stepText, action)];
+                case 10:
+                    _d.sent();
+                    _d.label = 11;
+                case 11:
+                    steps_1_1 = steps_1.next();
+                    return [3 /*break*/, 9];
+                case 12: return [3 /*break*/, 15];
+                case 13:
+                    e_1_1 = _d.sent();
+                    e_1 = { error: e_1_1 };
+                    return [3 /*break*/, 15];
+                case 14:
+                    try {
+                        if (steps_1_1 && !steps_1_1.done && (_c = steps_1.return)) _c.call(steps_1);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                    return [7 /*endfinally*/];
+                case 15: return [3 /*break*/, 17];
+                case 16:
+                    index_js_1.remult.dataProvider = prev;
+                    return [7 /*endfinally*/];
+                case 17: return [2 /*return*/];
+            }
+        });
+    });
+}
+exports.migrate = migrate;

package/migrations/migration-types.d.ts

@@ -0,0 +1,23 @@
+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>;
+}
+export interface MigrationCode {
+    addSql(sql: string): void;
+    addComment(comment: string): void;
+    addTypescriptCode(code: string): void;
+}
+export type Migrations = Record<number, (utils: MigrationUtils) => Promise<unknown>>;
+export type MigrationUtils = {
+    sql(sql: string): Promise<unknown>;
+};
+export declare class DefaultMigrationBuilder implements MigrationBuilder {
+    code: MigrationCode;
+    constructor(code: MigrationCode);
+    createTable(meta: EntityMetadata): Promise<void>;
+    addColumn(meta: EntityMetadata, field: FieldMetadata): Promise<void>;
+}

package/migrations/migration-types.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultMigrationBuilder = void 0;
+var tslib_1 = require("tslib");
+var DefaultMigrationBuilder = /** @class */ (function () {
+    function DefaultMigrationBuilder(code) {
+        this.code = code;
+    }
+    DefaultMigrationBuilder.prototype.createTable = function (meta) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                this.code.addComment('create table ' + meta.entityType.name);
+                return [2 /*return*/];
+            });
+        });
+    };
+    DefaultMigrationBuilder.prototype.addColumn = function (meta, field) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                this.code.addComment('add column ' + meta.entityType.name + '.' + field.key);
+                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>;