remult 0.25.8-exp.0 → 0.25.8-exp.2

package/esm/migrations/generate-migrations.js

@@ -4,12 +4,25 @@ import { compareMigrationSnapshot, emptySnapshot, } from './compare-migration-sn
 import { updateMigrationsFile } from './update-migrations-ts-file.js';
 import { DefaultMigrationBuilder, } from './migration-types.js';
 import { isOfType } from '../src/isOfType.js';
+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.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.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)
+ */
 export async function generateMigrations(options) {
-    const migrationDir = options.migrationsDir || path.join(process.cwd(), 'src/server/migrations');
-    const snapshotFileName = options.snapshotFileName ||
-        path.join(migrationDir, 'migrations-snapshot.json');
-    const migrationsTSFilename = options.migrationsTSFilename || path.join(migrationDir, 'migrations.ts');
-    const dataProvider = await options.dataProvider;
+    const migrationDir = options.migrationsFolder ||
+        path.join(process.cwd(), 'src/server/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);
     for (const p of [snapshotFileName, migrationsTSFilename]) {
         if (!fs.existsSync(path.dirname(p))) {
             fs.mkdirSync(path.dirname(p), { recursive: true });
@@ -44,4 +57,7 @@ export async function generateMigrations(options) {
             `async (${hasSql ? '{sql}' : ''})=>{\n${steps.join('\n')}\n}`,
         ]);
     fs.writeFileSync(snapshotFileName, JSON.stringify(snapshot, null, 2));
+    if (options.endConnection !== false && isOfType(dataProvider, 'end')) {
+        await dataProvider.end();
+    }
 }

package/esm/migrations/migrate.js

@@ -1,12 +1,21 @@
 import { __decorate, __metadata } from "tslib";
 import { Entity, IdEntity, Fields, remult, Remult, } from '../index.js';
+import { initDataProvider } from '../server/initDataProvider.js';
 import { doTransaction } from '../src/context.js';
-import { cast } from '../src/isOfType.js';
+import { cast, isOfType } from '../src/isOfType.js';
+/**
+ * Applies migration scripts to update the database schema.
+ *
+ * @param options - Configuration options for applying migrations.
+ * @param options.migrations - An object containing the migration scripts, each keyed by a unique identifier.
+ * @param options.dataProvider - The data provider instance or a function returning a promise of the data provider.
+ * @param options.migrationsTable - (Optional) The name of the table that tracks applied migrations. Default is '__remult_migrations_version'.
+ * @param options.endConnection - (Optional) Determines whether to close the database connection after applying migrations. Default is true.
+* @see [Migrations](http://remult.dev/docs/migrations.html)
+*/
 export async function migrate(options) {
-    let migrationTableName = options.migrationTableName || '__remult_migration_version';
-    const dataProvider = options.dataProvider
-        ? await options.dataProvider
-        : remult.dataProvider;
+    let migrationTableName = options.migrationsTable || '__remult_migrations_version';
+    const dataProvider = await initDataProvider(options.dataProvider);
     const prev = remult.dataProvider;
     remult.dataProvider = dataProvider;
     try {
@@ -36,15 +45,24 @@ export async function migrate(options) {
                 throw new Error('Migration step number must be a non-negative integer');
             if (v.version >= step)
                 continue;
-            console.info('Executing migration step', step);
-            await doTransaction(remult, async (dp) => {
-                const utils = {
-                    sql: async (sql) => {
-                        await cast(dp, 'execute').execute(sql);
-                    },
-                };
-                await action(utils);
-            });
+            console.info('Executing migration step ' + step);
+            console.time('Completed migration step ' + step);
+            try {
+                await doTransaction(remult, async (dp) => {
+                    const utils = {
+                        sql: async (sql) => {
+                            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;
+            }
             v.version = step;
             await v.save();
         }
@@ -52,4 +70,7 @@ export async function migrate(options) {
     finally {
         remult.dataProvider = prev;
     }
+    if (options.endConnection !== false && isOfType(dataProvider, 'end')) {
+        await dataProvider.end();
+    }
 }

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

@@ -10,7 +10,7 @@ export async function updateMigrationsFile(filePath, steps) {
         fs.writeFileSync(filePath, '');
     }
     const importPath = 'remult/migrations';
-    const importName = 'MigrationSteps';
+    const importName = 'Migrations';
     // Load the file
     const sourceFile = ts.createSourceFile(filePath, fs.readFileSync(filePath).toString(), ts.ScriptTarget.Latest, true);
     let migrationsExportFound = false;

package/esm/postgres/postgres-data-provider.js

@@ -1,3 +1,4 @@
+import { remult as defaultRemult } from '../src/remult-proxy.js';
 import pg from 'pg';
 const { Pool } = pg;
 import { Remult } from '../src/context.js';
@@ -7,9 +8,11 @@ export class PostgresDataProvider {
     pool;
     options;
     supportsJsonColumnType = true;
-    static getDb(remult) {
-        const sql = SqlDatabase.getDb(remult);
-        const me = sql._getSourceSql();
+    static getDb(dataProvider) {
+        const r = (dataProvider || defaultRemult.dataProvider);
+        if (!r._getSourceSql)
+            throw 'the data provider is not an SqlDatabase';
+        const me = r._getSourceSql();
         if (!me.pool) {
             throw 'the data provider is not a PostgresDataProvider';
         }
@@ -35,6 +38,9 @@ export class PostgresDataProvider {
             this.pool = new PostgresSchemaWrapper(pool, options.schema);
         }
     }
+    end() {
+        return this.pool.end();
+    }
     provideMigrationBuilder(builder) {
         var db = new SqlDatabase(this);
         var sb = new PostgresSchemaBuilder(db, this.options?.schema);
@@ -184,4 +190,7 @@ export class PostgresSchemaWrapper {
             c.release();
         }
     }
+    end() {
+        return this.pool.end();
+    }
 }

package/esm/remult-knex/index.js

@@ -13,6 +13,10 @@ export class KnexDataProvider {
     constructor(knex) {
         this.knex = knex;
     }
+    end() {
+        return this.knex.destroy();
+    }
+    /* @internal */
     provideMigrationBuilder(builder) {
         var sb = new KnexSchemaBuilder(this.knex);
         return {
@@ -37,8 +41,8 @@ export class KnexDataProvider {
     execute(sql) {
         return this.createCommand().execute(sql);
     }
-    static getDb(remult) {
-        const r = (remult || remultContext).dataProvider;
+    static getDb(dataProvider) {
+        const r = (dataProvider || remultContext.dataProvider);
         if (!r.knex)
             throw 'the data provider is not an KnexDataProvider';
         return r.knex;

package/esm/remult-mongo.js

@@ -16,8 +16,8 @@ export class MongoDataProvider {
     }
     session;
     disableTransactions = false;
-    static getDb(remult) {
-        const r = (remult || remultContext).dataProvider;
+    static getDb(dataProvider) {
+        const r = (dataProvider || remultContext.dataProvider);
         if (!r.db)
             throw 'the data provider is not a MongoDataProvider';
         return { db: r.db, session: r.session };

package/esm/remult-sql-js.js

@@ -6,6 +6,11 @@ export class SqlJsDataProvider {
     constructor(db) {
         this.db = db;
     }
+    orderByNullsFirst;
+    async end() {
+        ;
+        (await this.db).close();
+    }
     getLimitSqlSyntax(limit, offset) {
         return ' limit ' + limit + ' offset ' + offset;
     }

package/esm/server/expressBridge.js

@@ -13,6 +13,7 @@ import { serverActionField } from '../src/server-action-info.js';
 import { initDataProvider } from './initDataProvider.js';
 import { remultStatic } from '../src/remult-static.js';
 import remultAdminHtml from './remult-admin.js';
+import { isOfType } from '../src/isOfType.js';
 export function createRemultServerCore(options, serverCoreOptions) {
     if (!options) {
         options = {};
@@ -285,7 +286,7 @@ export class RemultServerImplementation {
                     genReq.params = req['_tempParams'];
             }
             let myReq = new ExpressRequestBridgeToDataApiRequest(genReq);
-            let myRes = new ExpressResponseBridgeToDataApiResponse(origRes, req);
+            let myRes = new ExpressResponseBridgeToDataApiResponse(origRes, req, this.options.error);
             try {
                 await this.runWithRemult(async (remult) => {
                     if (req) {
@@ -315,7 +316,7 @@ export class RemultServerImplementation {
                 });
             }
             catch (err) {
-                myRes.error(serializeError(err));
+                myRes.error(err, undefined);
             }
         };
     }
@@ -673,15 +674,17 @@ class ExpressRequestBridgeToDataApiRequest {
 class ExpressResponseBridgeToDataApiResponse {
     r;
     req;
+    handleError;
     forbidden() {
-        this.setStatus(403).end();
+        this.error({ message: 'Forbidden' }, undefined, 403);
     }
     setStatus(status) {
         return this.r.status(status);
     }
-    constructor(r, req) {
+    constructor(r, req, handleError) {
         this.r = r;
         this.req = req;
+        this.handleError = handleError;
     }
     progress(progress) { }
     success(data) {
@@ -694,22 +697,53 @@ class ExpressResponseBridgeToDataApiResponse {
         this.setStatus(204).end();
     }
     notFound() {
-        this.setStatus(404).end();
+        this.error({ message: 'Forbidden' }, undefined, 404);
     }
-    error(data) {
-        data = serializeError(data);
-        console.error({
-            message: data.message,
-            stack: data.stack?.split('\n'),
-            url: this.req?.url,
-            method: this.req?.method,
+    async error(exception, entity, httpStatusCode) {
+        let data = serializeError(exception);
+        if (!httpStatusCode) {
+            if (data.httpStatusCode) {
+                httpStatusCode = data.httpStatusCode;
+            }
+            else if (isOfType(exception, 'isForbiddenError') &&
+                exception.isForbiddenError) {
+                httpStatusCode = 403;
+            }
+            else if (data.modelState) {
+                httpStatusCode = 400;
+            }
+            else {
+                httpStatusCode = 500;
+            }
+        }
+        let responseSent = false;
+        const sendError = (httpStatusCode, body) => {
+            if (responseSent) {
+                throw Error('Error response already sent');
+            }
+            responseSent = true;
+            console.error({
+                message: body.message,
+                httpStatusCode,
+                stack: data.stack?.split('\n'),
+                url: this.req?.url,
+                method: this.req?.method,
+            });
+            this.setStatus(httpStatusCode).json(body);
+        };
+        await this.handleError?.({
+            httpStatusCode,
+            req: this.req,
+            entity,
+            exception,
+            responseBody: data,
+            sendError,
         });
-        this.setStatus(400).json(data);
+        if (!responseSent) {
+            sendError(httpStatusCode, data);
+        }
     }
 }
-function throwError() {
-    throw 'Invalid';
-}
 class inProcessQueueHandler {
     storage;
     constructor(storage) {

package/esm/src/data-api.js

@@ -61,7 +61,7 @@ export class DataApi {
             });
         }
         catch (err) {
-            response.error(err);
+            response.error(err, this.repository.metadata);
         }
     }
     async deleteMany(response, request, filterBody) {
@@ -79,7 +79,7 @@ export class DataApi {
             });
         }
         catch (err) {
-            response.error(err);
+            response.error(err, this.repository.metadata);
         }
     }
     async getArrayImpl(response, request, filterBody) {
@@ -159,7 +159,7 @@ export class DataApi {
             if (err.isForbiddenError)
                 response.forbidden();
             else
-                response.error(err);
+                response.error(err, this.repository.metadata);
         }
     }
     async liveQuery(response, request, filterBody, serializeContext, queryChannel) {
@@ -185,7 +185,7 @@ export class DataApi {
             if (err.isForbiddenError)
                 response.forbidden();
             else
-                response.error(err);
+                response.error(err, this.repository.metadata);
         }
     }
     async buildWhere(request, filterBody) {
@@ -232,13 +232,16 @@ export class DataApi {
                 if (r.length == 0)
                     response.notFound();
                 else if (r.length > 1)
-                    response.error({ message: 'id is not unique' });
+                    response.error({
+                        message: `id "${id}" is not unique for entity ` +
+                            this.repository.metadata.key,
+                    }, this.repository.metadata, 500);
                 else
                     await what(r[0]);
             });
         }
         catch (err) {
-            response.error(err);
+            response.error(err, this.repository.metadata);
         }
     }
     async updateMany(response, request, body) {
@@ -256,7 +259,7 @@ export class DataApi {
             });
         }
         catch (err) {
-            response.error(err);
+            response.error(err, this.repository.metadata);
         }
     }
     async actualUpdate(row, body) {
@@ -313,7 +316,7 @@ export class DataApi {
             if (err.isForbiddenError)
                 response.forbidden();
             else
-                response.error(err);
+                response.error(err, this.repository.metadata);
         }
     }
 }

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

@@ -10,8 +10,8 @@ import { isOfType } from '../isOfType.js';
 // @dynamic
 export class SqlDatabase {
     sql;
-    static getDb(remult) {
-        const r = (remult || defaultRemult).dataProvider;
+    static getDb(dataProvider) {
+        const r = (dataProvider || defaultRemult.dataProvider);
         if (isOfType(r, 'createCommand'))
             return r;
         else
@@ -76,6 +76,7 @@ export class SqlDatabase {
                     transaction: (z) => x.transaction(z),
                     supportsJsonColumnType: this.sql.supportsJsonColumnType,
                     wrapIdentifier: this.wrapIdentifier,
+                    end: this.end,
                 }));
             }
             finally {
@@ -121,10 +122,13 @@ export class SqlDatabase {
         if (isOfType(sql, 'provideMigrationBuilder')) {
             this.provideMigrationBuilder = sql.provideMigrationBuilder;
         }
+        if (isOfType(sql, 'end'))
+            this.end = () => sql.end();
     }
+    /* @internal */
     provideMigrationBuilder;
-    isProxy;
     createdEntities = [];
+    end;
 }
 const icons = new Map([
     // CRUD

package/esm/src/data-providers/web-sql-data-provider.js

@@ -13,15 +13,7 @@ export class WebSqlDataProvider {
         //@ts-ignore
         this.db = window.openDatabase(databaseName, '1.0', databaseName, databaseSize);
     }
-    // return instance of websql.Database class - see @types/websql
-    static getDb(remult) {
-        const sql = SqlDatabase.getDb(remult);
-        const me = sql._getSourceSql();
-        if (!me.db) {
-            throw 'the data provider is not a WebSqlDataProvider';
-        }
-        return me.db;
-    }
+    async end() { }
     getLimitSqlSyntax(limit, offset) {
         return ' limit ' + limit + ' offset ' + offset;
     }

package/esm/src/remult3/remult3.js

@@ -1,27 +1,17 @@
 export {};
-//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
+/*p1 - 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
 
-  - protect against deleting of all rows by mistake
-  - https://github.com/remult/remult/issues/221#issuecomment-2016519746
+- 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 - document offline support
 //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

package/esm/src/server-action.js

@@ -65,7 +65,7 @@ export class Action {
                     // got a problem in next with instance of ForbiddenError  - so replaced it with this bool
                     res.forbidden();
                 else
-                    res.error(err);
+                    res.error(err, undefined);
             }
         });
     }
@@ -245,7 +245,7 @@ export function BackendMethod(options) {
                                 // got a problem in next with instance of ForbiddenError  - so replaced it with this bool
                                 res.forbidden();
                             else
-                                res.error(err);
+                                res.error(err, undefined);
                         }
                     });
                 }

package/migrations/generate-migrations.d.ts

@@ -1,8 +1,21 @@
 import type { DataProvider } from '../index.js';
+/**
+ * Generates migration scripts based on changes in entities.
+ *
+ * @param options - Configuration options for generating migrations.
+ * @param options.entities - An array of entity classes to 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.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)
+ */
 export declare function generateMigrations(options: {
     entities: any[];
-    dataProvider: Promise<DataProvider> | DataProvider;
-    migrationsDir?: string;
-    snapshotFileName?: string;
-    migrationsTSFilename?: string;
+    dataProvider: DataProvider | Promise<DataProvider> | (() => Promise<DataProvider | undefined>);
+    migrationsFolder?: string;
+    snapshotFile?: string;
+    migrationsTSFile?: string;
+    endConnection?: boolean;
 }): Promise<void>;

package/migrations/generate-migrations.js

@@ -8,6 +8,19 @@ var compare_migration_snapshots_js_1 = require("./compare-migration-snapshots.js
 var update_migrations_ts_file_js_1 = require("./update-migrations-ts-file.js");
 var migration_types_js_1 = require("./migration-types.js");
 var isOfType_js_1 = require("../src/isOfType.js");
+var initDataProvider_js_1 = require("../server/initDataProvider.js");
+/**
+ * Generates migration scripts based on changes in entities.
+ *
+ * @param options - Configuration options for generating migrations.
+ * @param options.entities - An array of entity classes to 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.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)
+ */
 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;
@@ -15,11 +28,11 @@ function generateMigrations(options) {
         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];
+                    migrationDir = options.migrationsFolder ||
+                        path_1.default.join(process.cwd(), 'src/server/migrations');
+                    snapshotFileName = options.snapshotFile || path_1.default.join(migrationDir, 'migrations-snapshot.json');
+                    migrationsTSFilename = options.migrationsTSFile || path_1.default.join(migrationDir, 'migrations.ts');
+                    return [4 /*yield*/, (0, initDataProvider_js_1.initDataProvider)(options.dataProvider)];
                 case 1:
                     dataProvider = _d.sent();
                     try {
@@ -74,7 +87,12 @@ function generateMigrations(options) {
                     _d.label = 4;
                 case 4:
                     fs_1.default.writeFileSync(snapshotFileName, JSON.stringify(snapshot, null, 2));
-                    return [2 /*return*/];
+                    if (!(options.endConnection !== false && (0, isOfType_js_1.isOfType)(dataProvider, 'end'))) return [3 /*break*/, 6];
+                    return [4 /*yield*/, dataProvider.end()];
+                case 5:
+                    _d.sent();
+                    _d.label = 6;
+                case 6: return [2 /*return*/];
             }
         });
     });

package/migrations/migrate.d.ts

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