remult 0.25.8-exp.13 → 0.25.8-exp.15

package/esm/migrations/compare-migration-snapshots.js

@@ -1,15 +1,18 @@
 import { repo } from '../index.js';
 import { dbNamesOf, shouldCreateEntity, shouldNotCreateField, } from '../src/filter/filter-consumer-bridge-to-sql-request.js';
-export async function compareMigrationSnapshot({ entities, snapshot, migrationBuilder: migrationBuilder, }) {
+export async function compareMigrationSnapshot({ entities, snapshot, migrationBuilder, reporter, }) {
     snapshot = JSON.parse(JSON.stringify(snapshot));
+    let processedEntities = new Set();
     for (const entity of entities) {
         const meta = repo(entity).metadata;
         const e = await dbNamesOf(meta, (x) => x);
+        processedEntities.add(e.$entityName);
         if (shouldCreateEntity(meta, e)) {
             let entitySnapshot = snapshot.entities[e.$entityName];
             let createColumns = true;
             if (!entitySnapshot) {
                 createColumns = false;
+                reporter('create table ' + e.$entityName);
                 await migrationBuilder.createTable(meta);
                 entitySnapshot = snapshot.entities[e.$entityName] = {
                     key: meta.key,
@@ -17,16 +20,35 @@ export async function compareMigrationSnapshot({ entities, snapshot, migrationBu
                     columns: {},
                 };
             }
+            const processedColumns = new Set();
             for (const field of meta.fields) {
                 if (!shouldNotCreateField(field, e)) {
-                    const column = entitySnapshot.columns[e.$dbNameOf(field)];
+                    const columnDbName = e.$dbNameOf(field);
+                    processedColumns.add(columnDbName);
+                    const column = entitySnapshot.columns[columnDbName];
                     if (!column) {
-                        if (createColumns)
+                        if (createColumns) {
+                            reporter('add column ' + e.$entityName + '.' + columnDbName);
                             await migrationBuilder.addColumn(meta, field);
-                        entitySnapshot.columns[e.$dbNameOf(field)] = { key: field.key };
+                        }
+                        entitySnapshot.columns[columnDbName] = { key: field.key };
                     }
                 }
             }
+            for (const columnDbName of Object.keys(entitySnapshot.columns)) {
+                if (!processedColumns.has(columnDbName)) {
+                    reporter('remove column ' + e.$entityName + '.' + columnDbName);
+                    await migrationBuilder.removeColumn(e.$entityName, columnDbName);
+                    delete entitySnapshot.columns[columnDbName];
+                }
+            }
+        }
+    }
+    for (const entityDbName of Object.keys(snapshot.entities)) {
+        if (!processedEntities.has(entityDbName)) {
+            reporter('remove table ' + entityDbName);
+            await migrationBuilder.removeTable(entityDbName);
+            delete snapshot.entities[entityDbName];
         }
     }
     return snapshot;

package/esm/migrations/generate-migrations.js

@@ -9,17 +9,16 @@ import { initDataProvider } from '../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 to be included in the migration.
+ * @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/server/migrations'.
+ * @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 true.
- * @see [Migrations](http://remult.dev/docs/migrations.html)
+ * @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 async function generateMigrations(options) {
-    const migrationDir = options.migrationsFolder ||
-        path.join(process.cwd(), 'src/server/migrations');
+    const migrationDir = options.migrationsFolder || path.join(process.cwd(), 'src/migrations');
     const snapshotFileName = options.snapshotFile || path.join(migrationDir, 'migrations-snapshot.json');
     const migrationsTSFilename = options.migrationsTSFile || path.join(migrationDir, 'migrations.ts');
     const dataProvider = await initDataProvider(options.dataProvider);
@@ -45,19 +44,25 @@ export async function generateMigrations(options) {
     };
     let migrationBuilder = new DefaultMigrationBuilder(code);
     if (isOfType(dataProvider, 'provideMigrationBuilder')) {
-        migrationBuilder = dataProvider.provideMigrationBuilder(code);
+        migrationBuilder = new DefaultMigrationBuilder(code, dataProvider.provideMigrationBuilder(code));
     }
+    let reporter = (what) => console.log('[generateMigrations] ' + what);
     snapshot = await compareMigrationSnapshot({
         entities: options.entities,
         snapshot,
+        reporter,
         migrationBuilder,
     });
     if (steps.length)
         await updateMigrationsFile(migrationsTSFilename, [
             `async (${hasSql ? '{sql}' : ''})=>{\n${steps.join('\n')}\n}`,
         ]);
+    else {
+        reporter('No changes detected');
+    }
     fs.writeFileSync(snapshotFileName, JSON.stringify(snapshot, null, 2));
-    if (options.endConnection !== false && isOfType(dataProvider, 'end')) {
+    if (options.endConnection && isOfType(dataProvider, 'end')) {
         await dataProvider.end();
     }
+    return steps.length > 0;
 }

package/esm/migrations/migrate.js

@@ -10,9 +10,11 @@ import { cast, isOfType } from '../src/isOfType.js';
  * @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 true.
-* @see [Migrations](http://remult.dev/docs/migrations.html)
-*/
+ * @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 async function migrate(options) {
     let migrationTableName = options.migrationsTable || '__remult_migrations_version';
     const dataProvider = await initDataProvider(options.dataProvider);
@@ -29,48 +31,60 @@ export async function migrate(options) {
         VersionInfo = __decorate([
             Entity(migrationTableName)
         ], VersionInfo);
-        const repo = new Remult(dataProvider).repo(VersionInfo);
+        const steps = Object.entries(options.migrations).sort(([a], [b]) => parseInt(a) - parseInt(b));
         if (dataProvider.ensureSchema) {
-            await dataProvider.ensureSchema([repo.metadata]);
-        }
-        let v = await repo.findFirst();
-        if (!v) {
-            v = repo.create();
-            v.version = -1;
+            await dataProvider.ensureSchema([
+                new Remult(dataProvider).repo(VersionInfo).metadata,
+            ]);
         }
-        const steps = Object.entries(options.migrations).sort(([a], [b]) => parseInt(a) - parseInt(b));
-        for (const [stepText, action] of steps) {
-            const step = parseInt(stepText);
-            if (step < 0)
-                throw new Error('Migration step number must be a non-negative integer');
-            if (v.version >= step)
-                continue;
-            console.info('Executing migration step ' + step);
-            console.time('Completed migration step ' + step);
-            try {
-                await doTransaction(remult, async (dp) => {
+        await doTransaction(remult, async (dp) => {
+            const repo = new Remult(dataProvider).repo(VersionInfo, dp);
+            let v = await repo.findFirst();
+            if (!v) {
+                v = repo.create();
+                v.version = -1;
+            }
+            for (const [stepText, action] of steps) {
+                const step = parseInt(stepText);
+                if (step < 0)
+                    throw new Error('Migration step number must be a non-negative integer');
+                if (v.version >= step)
+                    continue;
+                if (options.beforeMigration) {
+                    await options.beforeMigration({ index: step });
+                }
+                const startTime = Date.now();
+                console.info('Executing migration step ' + step);
+                console.time('Completed migration step ' + step);
+                try {
                     const utils = {
                         sql: async (sql) => {
-                            await cast(dp, 'execute').execute(sql);
+                            return await cast(dp, 'execute').execute(sql);
                         },
                     };
                     await action(utils);
-                });
-                console.timeEnd('Completed migration step ' + step);
-            }
-            catch (err) {
-                console.error('Failed to execute migration step ' + step);
-                console.error(err);
-                throw err;
+                    if (options.afterMigration) {
+                        await options.afterMigration({
+                            index: step,
+                            duration: Date.now() - startTime,
+                        });
+                    }
+                    console.timeEnd('Completed migration step ' + step);
+                }
+                catch (err) {
+                    console.error('Failed to execute migration step ' + step);
+                    console.error(err);
+                    throw err;
+                }
+                v.version = step;
+                await v.save();
             }
-            v.version = step;
-            await v.save();
-        }
+        });
     }
     finally {
         remult.dataProvider = prev;
     }
-    if (options.endConnection !== false && isOfType(dataProvider, 'end')) {
+    if (options.endConnection && isOfType(dataProvider, 'end')) {
         await dataProvider.end();
     }
 }

package/esm/migrations/migration-types.js

@@ -1,12 +1,36 @@
 export class DefaultMigrationBuilder {
     code;
-    constructor(code) {
+    wrapped;
+    constructor(code, wrapped) {
         this.code = code;
+        this.wrapped = wrapped;
     }
     async createTable(meta) {
-        this.code.addComment('create table ' + meta.entityType.name);
+        if (this.wrapped?.createTable) {
+            await this.wrapped.createTable(meta);
+        }
+        else
+            this.code.addComment('TODO: implement create table ' + meta.dbName);
     }
     async addColumn(meta, field) {
-        this.code.addComment('add column ' + meta.entityType.name + '.' + field.key);
+        if (this.wrapped?.addColumn) {
+            await this.wrapped.addColumn(meta, field);
+        }
+        else
+            this.code.addComment('TODO: implement add column ' + meta.dbName + '.' + field.dbName);
+    }
+    async removeTable(entityDbName) {
+        if (this.wrapped?.removeTable) {
+            await this.wrapped.removeTable(entityDbName);
+        }
+        else
+            this.code.addComment('TODO: implement remove table ' + entityDbName);
+    }
+    async removeColumn(entityName, columnDbName) {
+        if (this.wrapped?.removeColumn) {
+            await this.wrapped.removeColumn(entityName, columnDbName);
+        }
+        else
+            this.code.addComment('TODO: implement remove column ' + entityName + '.' + columnDbName);
     }
 }

package/esm/migrations/update-migrations-ts-file.js

@@ -1,6 +1,9 @@
 // consider replacing with https://www.npmjs.com/package/ts-morph
 export async function updateMigrationsFile(filePath, steps) {
-    const ts = await import('typescript');
+    let ts = await import('typescript');
+    //@ts-ignore
+    if (ts.default)
+        ts = ts.default;
     const fs = await import('fs');
     let maxStep = -1;
     function buildSteps() {

package/esm/src/filter/filter-interfaces.js

@@ -64,6 +64,27 @@ export class Filter {
         await Filter.fromEntityFilter(metadata, filter).__applyToConsumer(result);
         return result;
     }
+    /**
+     * Retrieves information about a filter, including precise values for each property.
+     * @template entityType The type of the entity being filtered.
+     * @param metadata The metadata of the entity being filtered.
+     * @param filter The filter to analyze.
+     * @returns A promise that resolves to a FilterInfo object containing the filter information.
+     * @example
+     * const info = await where.getInfo();
+     * console.log(info.preciseValues);
+     * // Output:
+     * // {
+     * //   "customerId": ["1", "2", "3"], // Precise values inferred from the filter
+     * //   "status": undefined,           // Cannot infer precise values for 'status'
+     * // }
+    
+     */
+    async getInfo() {
+        const result = new preciseValuesCollector();
+        await this.__applyToConsumer(result);
+        return result;
+    }
     static createCustom(rawFilterTranslator, key = '') {
         let rawFilterInfo = { key: key, rawFilterTranslator };
         return Object.assign((x) => {
@@ -248,7 +269,6 @@ export class Filter {
             return await filter();
         return filter;
     }
-    //@internal
     toJson() {
         let r = new FilterSerializer();
         this.__applyToConsumer(r);

package/esm/src/remult3/remult3.js

@@ -1,20 +1,24 @@
 export {};
-//p1 - It's good that there is no migrations added. (I also don't like automatic deletion), and it can be done manually if needed.
-//p1 - Maybe migrations-snapshots.json should have fields deleted to have a one to one representation of the db?
+//p1 DOC DONE - It's good that there is no migrations added. (I also don't like automatic deletion), and it can be done manually if needed.
+//p1 DOC DONE - Maybe migrations-snapshots.json should have fields deleted to have a one to one representation of the db?
+//p1 DOC DONE - @JYT - should I write to console on generate migrations, what are the changes that I've found / the migration step id / not changes found
+//p1 DOC DONE - re-discuss endConnection - default false - explain in docs
+//p1 DONE - JYC log the migration request - beforeMigration. afterMigration
+//p1 DONE - migration default folder should be source/migrations (also docs?)
+//p1 DONE - @JYT run all migrations in a single transaction? or transaction per step?
+//p1 Done - Filter.toJson should be public
 //p1 - I needed to modify the changes Field of changeLog entity to @Fields.json() to be nvarchar(max) too. Why is @Fields.object() only nvarchar(255) ? Or is it default size and can be adjusted?
-//p1 - Filter.toJson should be public
-//p1 - improve type augmentation doc with specific of the file and with the export trick
-//y1 - JY build issue
-//p1 - JY issue with the generate migration
-//y1 - migration default folder should be source/migrations (also docs?)
-//y1 - discuss the typing issue with relations in this case vs the ValueListFieldTypes
-//y1 - JYC log the migration request
-//y1 - JYC health check approach
+//p1 - improve type augmentation doc with specific of the file and with the export trick - fix code samples to init reqiest error
+//p1 - document custom filter without sql
+//y1!! - JY build issue
+//p1 - discuss the typing issue with relations in this case vs the ValueListFieldTypes - return partial with id values.
 //p1 - admin url1 - pocketbase use /_ for the admin //{allowed?:Allowed,url?:string}
 //p1 - document new sqlite providers
 //p1 - article auth.js with express
 //p1 - document offline support
 //p1 - fix getting started article with using your own database connection
+//p1 - create foreign key constraints in user code
+//p1 - https://github.com/vuejs/vitepress/issues/3154#issuecomment-1784612839
 //y2 - should we validate relations
 //y1 - dependency of live query tables
 //y1 - consider replacing all errors with error classes that extend the base Error class

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

@@ -1,8 +1,9 @@
 import type { MigrationBuilder } from './migration-types.js';
-export declare function compareMigrationSnapshot({ entities, snapshot, migrationBuilder: migrationBuilder, }: {
+export declare function compareMigrationSnapshot({ entities, snapshot, migrationBuilder, reporter, }: {
     entities: any[];
     snapshot: EntitiesSnapshot;
-    migrationBuilder: MigrationBuilder;
+    migrationBuilder: Required<MigrationBuilder>;
+    reporter: (what: string) => void;
 }): Promise<{
     version: number;
     entities: Record<string, {

package/migrations/compare-migration-snapshots.js

@@ -5,87 +5,152 @@ 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;
+    var entities = _a.entities, snapshot = _a.snapshot, migrationBuilder = _a.migrationBuilder, reporter = _a.reporter;
     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) {
+        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));
-                    _f.label = 1;
+                    processedEntities = new Set();
+                    _m.label = 1;
                 case 1:
-                    _f.trys.push([1, 15, 16, 17]);
+                    _m.trys.push([1, 23, 24, 25]);
                     entities_1 = tslib_1.__values(entities), entities_1_1 = entities_1.next();
-                    _f.label = 2;
+                    _m.label = 2;
                 case 2:
-                    if (!!entities_1_1.done) return [3 /*break*/, 14];
+                    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 = _f.sent();
-                    if (!(0, filter_consumer_bridge_to_sql_request_js_1.shouldCreateEntity)(meta, e)) return [3 /*break*/, 13];
+                    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:
-                    _f.sent();
+                    _m.sent();
                     entitySnapshot = snapshot.entities[e.$entityName] = {
                         key: meta.key,
                         className: meta.entityType.name,
                         columns: {},
                     };
-                    _f.label = 5;
+                    _m.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;
+                    processedColumns = new Set();
+                    _m.label = 6;
                 case 6:
-                    if (!!_c.done) return [3 /*break*/, 10];
+                    _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*/, 9];
-                    column = entitySnapshot.columns[e.$dbNameOf(field)];
-                    if (!!column) return [3 /*break*/, 9];
-                    if (!createColumns) return [3 /*break*/, 8];
+                    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 7:
-                    _f.sent();
-                    _f.label = 8;
                 case 8:
-                    entitySnapshot.columns[e.$dbNameOf(field)] = { key: field.key };
-                    _f.label = 9;
+                    _m.sent();
+                    _m.label = 9;
                 case 9:
+                    entitySnapshot.columns[columnDbName] = { key: field.key };
+                    _m.label = 10;
+                case 10:
                     _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];
+                    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 && (_e = _b.return)) _e.call(_b);
+                        if (_c && !_c.done && (_j = _b.return)) _j.call(_b);
                     }
                     finally { if (e_1) throw e_1.error; }
                     return [7 /*endfinally*/];
-                case 13:
-                    entities_1_1 = entities_1.next();
-                    return [3 /*break*/, 2];
-                case 14: return [3 /*break*/, 17];
+                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:
-                    e_2_1 = _f.sent();
-                    e_2 = { error: e_2_1 };
-                    return [3 /*break*/, 17];
+                    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 (entities_1_1 && !entities_1_1.done && (_d = entities_1.return)) _d.call(entities_1);
+                        if (_e && !_e.done && (_k = _d.return)) _k.call(_d);
                     }
                     finally { if (e_2) throw e_2.error; }
                     return [7 /*endfinally*/];
-                case 17: return [2 /*return*/, snapshot];
+                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];
             }
         });
     });

package/migrations/generate-migrations.d.ts

@@ -3,13 +3,13 @@ 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 to be included in the migration.
+ * @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/server/migrations'.
+ * @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 true.
- * @see [Migrations](http://remult.dev/docs/migrations.html)
+ * @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[];
@@ -18,4 +18,4 @@ export declare function generateMigrations(options: {
     snapshotFile?: string;
     migrationsTSFile?: string;
     endConnection?: boolean;
-}): Promise<void>;
+}): Promise<boolean>;

package/migrations/generate-migrations.js

@@ -13,23 +13,22 @@ 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 to be included in the migration.
+ * @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/server/migrations'.
+ * @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 true.
- * @see [Migrations](http://remult.dev/docs/migrations.html)
+ * @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;
+        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/server/migrations');
+                    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)];
@@ -69,11 +68,13 @@ function generateMigrations(options) {
                     };
                     migrationBuilder = new migration_types_js_1.DefaultMigrationBuilder(code);
                     if ((0, isOfType_js_1.isOfType)(dataProvider, 'provideMigrationBuilder')) {
-                        migrationBuilder = dataProvider.provideMigrationBuilder(code);
+                        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:
@@ -84,15 +85,18 @@ function generateMigrations(options) {
                         ])];
                 case 3:
                     _d.sent();
-                    _d.label = 4;
+                    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 !== false && (0, isOfType_js_1.isOfType)(dataProvider, 'end'))) return [3 /*break*/, 6];
+                    if (!(options.endConnection && (0, isOfType_js_1.isOfType)(dataProvider, 'end'))) return [3 /*break*/, 7];
                     return [4 /*yield*/, dataProvider.end()];
-                case 5:
+                case 6:
                     _d.sent();
-                    _d.label = 6;
-                case 6: return [2 /*return*/];
+                    _d.label = 7;
+                case 7: return [2 /*return*/, steps.length > 0];
             }
         });
     });

package/migrations/migrate.d.ts

@@ -7,12 +7,21 @@ import type { Migrations } from './migration-types.js';
  * @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 true.
-* @see [Migrations](http://remult.dev/docs/migrations.html)
-*/
+ * @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

@@ -13,27 +13,28 @@ var isOfType_js_1 = require("../src/isOfType.js");
  * @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 true.
-* @see [Migrations](http://remult.dev/docs/migrations.html)
-*/
+ * @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, repo, v, steps, _loop_1, steps_1, steps_1_1, _a, stepText, action, e_1_1;
-        var e_1, _b;
+        var migrationTableName, dataProvider, prev, VersionInfo_1, steps_1;
         var _this = this;
-        return tslib_1.__generator(this, function (_c) {
-            switch (_c.label) {
+        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 = _c.sent();
+                    dataProvider = _a.sent();
                     prev = index_js_1.remult.dataProvider;
                     index_js_1.remult.dataProvider = dataProvider;
-                    _c.label = 2;
+                    _a.label = 2;
                 case 2:
-                    _c.trys.push([2, , 14, 15]);
-                    VersionInfo = /** @class */ (function (_super) {
+                    _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;
@@ -43,125 +44,130 @@ function migrate(options) {
                         tslib_1.__decorate([
                             index_js_1.Fields.number(),
                             tslib_1.__metadata("design:type", Object)
-                        ], VersionInfo.prototype, "version", void 0);
+                        ], VersionInfo_1.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*/, 4];
-                    return [4 /*yield*/, dataProvider.ensureSchema([repo.metadata])];
-                case 3:
-                    _c.sent();
-                    _c.label = 4;
-                case 4: return [4 /*yield*/, repo.findFirst()];
-                case 5:
-                    v = _c.sent();
-                    if (!v) {
-                        v = repo.create();
-                        v.version = -1;
-                    }
-                    steps = Object.entries(options.migrations).sort(function (_a, _b) {
+                    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);
                     });
-                    _loop_1 = function (stepText, action) {
-                        var step, err_1;
-                        return tslib_1.__generator(this, function (_d) {
-                            switch (_d.label) {
+                    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 [2 /*return*/, "continue"];
+                                        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);
-                                    _d.label = 1;
-                                case 1:
-                                    _d.trys.push([1, 3, , 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 utils;
-                                            var _this = this;
+                                    _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:
-                                                        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 0: return [4 /*yield*/, (0, isOfType_js_1.cast)(dp, 'execute').execute(sql)];
+                                                    case 1: return [2 /*return*/, _a.sent()];
                                                 }
                                             });
-                                        }); })];
-                                case 2:
-                                    _d.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*/, 4];
-                                case 3:
-                                    err_1 = _d.sent();
+                                    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 4:
+                                case 11:
                                     v.version = step;
                                     return [4 /*yield*/, v.save()];
-                                case 5:
-                                    _d.sent();
-                                    return [2 /*return*/];
+                                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*/];
                             }
                         });
-                    };
-                    _c.label = 6;
-                case 6:
-                    _c.trys.push([6, 11, 12, 13]);
-                    steps_1 = tslib_1.__values(steps), steps_1_1 = steps_1.next();
-                    _c.label = 7;
-                case 7:
-                    if (!!steps_1_1.done) return [3 /*break*/, 10];
-                    _a = tslib_1.__read(steps_1_1.value, 2), stepText = _a[0], action = _a[1];
-                    return [5 /*yield**/, _loop_1(stepText, action)];
-                case 8:
-                    _c.sent();
-                    _c.label = 9;
-                case 9:
-                    steps_1_1 = steps_1.next();
+                    }); })];
+                case 5:
+                    _a.sent();
                     return [3 /*break*/, 7];
-                case 10: return [3 /*break*/, 13];
-                case 11:
-                    e_1_1 = _c.sent();
-                    e_1 = { error: e_1_1 };
-                    return [3 /*break*/, 13];
-                case 12:
-                    try {
-                        if (steps_1_1 && !steps_1_1.done && (_b = steps_1.return)) _b.call(steps_1);
-                    }
-                    finally { if (e_1) throw e_1.error; }
-                    return [7 /*endfinally*/];
-                case 13: return [3 /*break*/, 15];
-                case 14:
+                case 6:
                     index_js_1.remult.dataProvider = prev;
                     return [7 /*endfinally*/];
-                case 15:
-                    if (!(options.endConnection !== false && (0, isOfType_js_1.isOfType)(dataProvider, 'end'))) return [3 /*break*/, 17];
+                case 7:
+                    if (!(options.endConnection && (0, isOfType_js_1.isOfType)(dataProvider, 'end'))) return [3 /*break*/, 9];
                     return [4 /*yield*/, dataProvider.end()];
-                case 16:
-                    _c.sent();
-                    _c.label = 17;
-                case 17: return [2 /*return*/];
+                case 8:
+                    _a.sent();
+                    _a.label = 9;
+                case 9: return [2 /*return*/];
             }
         });
     });

package/migrations/migration-types.d.ts

@@ -5,6 +5,8 @@ export interface CanBuildMigrations {
 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;
@@ -35,9 +37,12 @@ export type Migrations = Record<number, (utils: MigrationUtils) => Promise<unkno
 export type MigrationUtils = {
     sql(sql: string): Promise<unknown>;
 };
-export declare class DefaultMigrationBuilder implements MigrationBuilder {
+export declare class DefaultMigrationBuilder implements Required<MigrationBuilder> {
     code: MigrationCode;
-    constructor(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

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

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

@@ -16,6 +16,9 @@ function updateMigrationsFile(filePath, steps) {
                 case 0: return [4 /*yield*/, Promise.resolve().then(function () { return tslib_1.__importStar(require('typescript')); })];
                 case 1:
                     ts = _a.sent();
+                    //@ts-ignore
+                    if (ts.default)
+                        ts = ts.default;
                     return [4 /*yield*/, Promise.resolve().then(function () { return tslib_1.__importStar(require('fs')); })];
                 case 2:
                     fs = _a.sent();

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "remult",
-    "version": "0.25.8-exp.13",
+    "version": "0.25.8-exp.15",
     "description": "A CRUD framework for full-stack TypeScript",
     "homepage": "https://remult.dev",
     "repository": {

package/src/filter/filter-interfaces.d.ts

@@ -30,6 +30,23 @@ export declare class Filter {
     
      */
     static getInfo<entityType>(metadata: EntityMetadata<entityType>, filter: EntityFilter<entityType>): Promise<FilterInfo<entityType>>;
+    /**
+     * Retrieves information about a filter, including precise values for each property.
+     * @template entityType The type of the entity being filtered.
+     * @param metadata The metadata of the entity being filtered.
+     * @param filter The filter to analyze.
+     * @returns A promise that resolves to a FilterInfo object containing the filter information.
+     * @example
+     * const info = await where.getInfo();
+     * console.log(info.preciseValues);
+     * // Output:
+     * // {
+     * //   "customerId": ["1", "2", "3"], // Precise values inferred from the filter
+     * //   "status": undefined,           // Cannot infer precise values for 'status'
+     * // }
+    
+     */
+    getInfo<entityType>(): Promise<FilterInfo<entityType>>;
     /**
      * Creates a custom filter. Custom filters are evaluated on the backend, ensuring security and efficiency.
      * When the filter is used in the frontend, only its name is sent to the backend via the API,
@@ -158,6 +175,7 @@ export declare class Filter {
      * @returns {Promise<EntityFilter<entityType>>} The resolved entity filter.
      */
     static resolve<entityType>(filter: EntityFilter<entityType> | (() => EntityFilter<entityType> | Promise<EntityFilter<entityType>>)): Promise<EntityFilter<entityType>>;
+    toJson(): any;
 }
 export interface FilterConsumer {
     or(orElements: Filter[]): any;

package/src/filter/filter-interfaces.js

@@ -101,6 +101,37 @@ var Filter = /** @class */ (function () {
             });
         });
     };
+    /**
+     * Retrieves information about a filter, including precise values for each property.
+     * @template entityType The type of the entity being filtered.
+     * @param metadata The metadata of the entity being filtered.
+     * @param filter The filter to analyze.
+     * @returns A promise that resolves to a FilterInfo object containing the filter information.
+     * @example
+     * const info = await where.getInfo();
+     * console.log(info.preciseValues);
+     * // Output:
+     * // {
+     * //   "customerId": ["1", "2", "3"], // Precise values inferred from the filter
+     * //   "status": undefined,           // Cannot infer precise values for 'status'
+     * // }
+    
+     */
+    Filter.prototype.getInfo = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var result;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        result = new preciseValuesCollector();
+                        return [4 /*yield*/, this.__applyToConsumer(result)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/, result];
+                }
+            });
+        });
+    };
     Filter.createCustom = function (rawFilterTranslator, key) {
         if (key === void 0) { key = ''; }
         var rawFilterInfo = { key: key, rawFilterTranslator: rawFilterTranslator };
@@ -295,7 +326,6 @@ var Filter = /** @class */ (function () {
             });
         });
     };
-    //@internal
     Filter.prototype.toJson = function () {
         var r = new FilterSerializer();
         this.__applyToConsumer(r);

package/src/remult3/remult3.d.ts

@@ -240,7 +240,7 @@ export declare type MembersOnly<T> = {
 };
 export declare type idType<entityType> = entityType extends {
     id?: infer U;
-} ? U : string | number;
+} ? U extends string ? string : U extends number ? number : string | number : string | number;
 /**used to perform CRUD operations on an `entityType` */
 export interface Repository<entityType> {
     /** returns a result array based on the provided options */

package/src/remult3/remult3.js

@@ -1,21 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//p1 - It's good that there is no migrations added. (I also don't like automatic deletion), and it can be done manually if needed.
-//p1 - Maybe migrations-snapshots.json should have fields deleted to have a one to one representation of the db?
+//p1 DOC DONE - It's good that there is no migrations added. (I also don't like automatic deletion), and it can be done manually if needed.
+//p1 DOC DONE - Maybe migrations-snapshots.json should have fields deleted to have a one to one representation of the db?
+//p1 DOC DONE - @JYT - should I write to console on generate migrations, what are the changes that I've found / the migration step id / not changes found
+//p1 DOC DONE - re-discuss endConnection - default false - explain in docs
+//p1 DONE - JYC log the migration request - beforeMigration. afterMigration
+//p1 DONE - migration default folder should be source/migrations (also docs?)
+//p1 DONE - @JYT run all migrations in a single transaction? or transaction per step?
+//p1 Done - Filter.toJson should be public
 //p1 - I needed to modify the changes Field of changeLog entity to @Fields.json() to be nvarchar(max) too. Why is @Fields.object() only nvarchar(255) ? Or is it default size and can be adjusted?
-//p1 - Filter.toJson should be public
-//p1 - improve type augmentation doc with specific of the file and with the export trick
-//y1 - JY build issue
-//p1 - JY issue with the generate migration
-//y1 - migration default folder should be source/migrations (also docs?)
-//y1 - discuss the typing issue with relations in this case vs the ValueListFieldTypes
-//y1 - JYC log the migration request
-//y1 - JYC health check approach
+//p1 - improve type augmentation doc with specific of the file and with the export trick - fix code samples to init reqiest error
+//p1 - document custom filter without sql
+//y1!! - JY build issue
+//p1 - discuss the typing issue with relations in this case vs the ValueListFieldTypes - return partial with id values.
 //p1 - admin url1 - pocketbase use /_ for the admin //{allowed?:Allowed,url?:string}
 //p1 - document new sqlite providers
 //p1 - article auth.js with express
 //p1 - document offline support
 //p1 - fix getting started article with using your own database connection
+//p1 - create foreign key constraints in user code
+//p1 - https://github.com/vuejs/vitepress/issues/3154#issuecomment-1784612839
 //y2 - should we validate relations
 //y1 - dependency of live query tables
 //y1 - consider replacing all errors with error classes that extend the base Error class