remult 0.22.3 → 0.22.5

package/esm/core/server/index.d.ts

@@ -0,0 +1,6 @@
+import { RemultServer, RemultServerOptions, ServerCoreOptions } from './expressBridge';
+export { queuedJobInfo, QueueStorage, GenericRequestInfo, GenericRequestHandler, RemultServerCore, GenericResponse, GenericRouter, RemultServerOptions, SpecificRoute, RemultServer, InitRequestOptions } from './expressBridge';
+export { JsonEntityFileStorage, JsonFileDataProvider } from './JsonEntityFileStorage';
+export { DataProviderLiveQueryStorage } from '../live-query/data-provider-live-query-storage';
+export { SseSubscriptionServer } from '../SseSubscriptionServer';
+export declare function createRemultServer<RequestType>(options: RemultServerOptions<RequestType>, serverCoreOptions?: ServerCoreOptions<RequestType>): RemultServer<RequestType>;

package/esm/core/server/index.js

@@ -0,0 +1,9 @@
+import { createRemultServerCore, } from './expressBridge';
+import { initAsyncHooks } from './initAsyncHooks';
+export { JsonEntityFileStorage, JsonFileDataProvider } from './JsonEntityFileStorage';
+export { DataProviderLiveQueryStorage } from '../live-query/data-provider-live-query-storage';
+export { SseSubscriptionServer } from '../SseSubscriptionServer';
+export function createRemultServer(options, serverCoreOptions) {
+    initAsyncHooks();
+    return createRemultServerCore(options, serverCoreOptions || { buildGenericRequestInfo: req => req, getRequestBody: async (req) => req.body });
+}

package/esm/core/server/initAsyncHooks.d.ts

@@ -0,0 +1 @@
+export declare function initAsyncHooks(): void;

package/esm/core/server/initAsyncHooks.js

@@ -0,0 +1,9 @@
+import { AsyncLocalStorage } from 'async_hooks';
+import { RemultAsyncLocalStorage } from '../src/context';
+let init = false;
+export function initAsyncHooks() {
+    if (init)
+        return;
+    init = true;
+    RemultAsyncLocalStorage.instance = new RemultAsyncLocalStorage(new AsyncLocalStorage());
+}

package/esm/core/server/initDataProvider.d.ts

@@ -0,0 +1,2 @@
+import { DataProvider } from '../src/data-interfaces';
+export declare function initDataProvider(optionsDataProvider?: DataProvider | Promise<DataProvider> | (() => Promise<DataProvider | undefined>)): Promise<DataProvider>;

package/esm/core/server/initDataProvider.js

@@ -0,0 +1,14 @@
+export function initDataProvider(optionsDataProvider) {
+    let dataProvider;
+    if (typeof optionsDataProvider === "function") {
+        dataProvider = optionsDataProvider();
+    }
+    else
+        dataProvider = Promise.resolve(optionsDataProvider);
+    dataProvider = dataProvider.then(async (dp) => {
+        if (dp)
+            return dp;
+        return new (await import('./JsonEntityFileStorage')).JsonFileDataProvider('./db');
+    });
+    return dataProvider;
+}

package/esm/core/src/__EntityValueProvider.d.ts

@@ -0,0 +1,11 @@
+export interface packedRowInfo {
+    data: any;
+    isNewRow: boolean;
+    id: string;
+    wasChanged: boolean;
+}
+export interface entityEventListener<entityType> {
+    deleted?: (entity: entityType) => void;
+    saved?: (entity: entityType, isNew: boolean) => void;
+    validating?: (entity: entityType) => Promise<any> | any;
+}

package/esm/core/src/__EntityValueProvider.js

@@ -0,0 +1 @@
+export {};

package/esm/core/src/__RowsOfDataForTesting.d.ts

@@ -0,0 +1,3 @@
+export interface __RowsOfDataForTesting {
+    rows: any;
+}

package/esm/core/src/__RowsOfDataForTesting.js

@@ -0,0 +1 @@
+export {};

package/esm/core/src/backend-tests/backend-database-test-setup.backend-spec.d.ts

@@ -0,0 +1,6 @@
+import { dbTestWhatSignature } from "../shared-tests/db-tests-setup";
+export declare const testKnexPGSqlImpl: (key: string, what: dbTestWhatSignature, focus?: boolean) => void;
+export declare const mySqlTest: import("../shared-tests/db-tests-setup").dbTestMethodSignature;
+export declare function testPostgresImplementation(key: string, what: dbTestWhatSignature, focus?: boolean): void;
+export declare function testMongo(key: string, what: dbTestWhatSignature, focus?: boolean): void;
+import '../shared-tests';

package/esm/core/src/backend-tests/backend-database-test-setup.backend-spec.js

@@ -0,0 +1,147 @@
+import { Remult } from "../context";
+import { KnexDataProvider, KnexSchemaBuilder } from '../../remult-knex';
+import * as Knex from 'knex';
+import { MongoClient } from 'mongodb';
+import { config } from 'dotenv';
+import { createPostgresConnection, PostgresSchemaBuilder } from "../../postgres";
+import { addDatabaseToTest, itWithFocus, testAll, TestDbs } from "../shared-tests/db-tests-setup";
+import { describeClass } from "../remult3/DecoratorReplacer";
+import { Entity, Fields } from "../remult3";
+KnexSchemaBuilder.logToConsole = false;
+PostgresSchemaBuilder.logToConsole = false;
+config();
+function testKnexSqlImpl(knex, name) {
+    return (key, what, focus = false) => {
+        itWithFocus(key + " " + name + " - knex", async () => {
+            let db = new KnexDataProvider(knex);
+            let remult = new Remult(db);
+            await what({
+                db, remult,
+                createEntity: async (entity) => {
+                    let repo = remult.repo(entity);
+                    await knex.schema.dropTableIfExists(await repo.metadata.getDbName());
+                    await db.ensureSchema([repo.metadata]);
+                    return repo;
+                }
+            });
+        }, focus);
+    };
+}
+export const testKnexPGSqlImpl = testKnexSqlImpl(Knex.default({
+    client: 'pg',
+    connection: process.env.DATABASE_URL,
+    //debug:true
+}), "postgres");
+addDatabaseToTest(testKnexPGSqlImpl);
+if (process.env['TESTS_SQL_SERVER'])
+    addDatabaseToTest(testKnexSqlImpl(Knex.default({
+        client: 'mssql',
+        connection: {
+            server: '127.0.0.1',
+            database: 'test2',
+            user: 'sa',
+            password: 'MASTERKEY',
+            options: {
+                enableArithAbort: true,
+                encrypt: false,
+                instanceName: 'sqlexpress'
+            }
+        } //,debug: true
+    }), "sql server"));
+if (true)
+    addDatabaseToTest(testKnexSqlImpl(Knex.default({
+        client: 'better-sqlite3',
+        connection: {
+            filename: ":memory:"
+        },
+        //debug: true
+    }), "sqlite3"));
+export const mySqlTest = addDatabaseToTest(testKnexSqlImpl(Knex.default({
+    client: 'mysql2',
+    connection: {
+        user: 'root',
+        password: 'MASTERKEY',
+        host: '127.0.0.1',
+        database: 'test'
+    }
+    //debug: true
+}), "mysql2"));
+let pg = createPostgresConnection();
+export function testPostgresImplementation(key, what, focus = false) {
+    itWithFocus(key + " - postgres", async () => {
+        let db = await pg;
+        let remult = new Remult(db);
+        await what({
+            db, remult,
+            createEntity: async (entity) => {
+                let repo = remult.repo(entity);
+                await db.execute("drop table if exists " + await repo.metadata.getDbName());
+                await db.ensureSchema([repo.metadata]);
+                return repo;
+            }
+        });
+    }, focus);
+}
+addDatabaseToTest(testPostgresImplementation);
+import { Categories } from "../tests/remult-3-entities";
+import { MongoDataProvider } from "../../remult-mongo";
+testAll("transactions", async ({ db, createEntity }) => {
+    let x = await createEntity(Categories);
+    await db.transaction(async (db) => {
+        let remult = new Remult(db);
+        expect(await remult.repo(Categories).count()).toBe(0);
+    });
+});
+const mongoConnectionString = process.env['MONGO_TEST_URL']; //"mongodb://localhost:27017/local"
+let client = new MongoClient(mongoConnectionString);
+let done;
+let mongoDbPromise = client.connect().then(c => {
+    done = c;
+    return c.db("test");
+});
+afterAll(async () => {
+    if (done)
+        done.close();
+});
+export function testMongo(key, what, focus = false) {
+    itWithFocus(key + " - mongo", async () => {
+        let mongoDb = await mongoDbPromise;
+        let db = new MongoDataProvider(mongoDb, client);
+        let remult = new Remult(db);
+        await what({
+            db, remult,
+            createEntity: async (entity) => {
+                let repo = remult.repo(entity);
+                await mongoDb.collection(await repo.metadata.getDbName()).deleteMany({});
+                return repo;
+            }
+        });
+    }, focus);
+}
+addDatabaseToTest(testMongo, TestDbs.mongo);
+it("test mongo without transaction", async () => {
+    const client = new MongoClient("mongodb://localhost:27017/local");
+    await client.connect();
+    const mongoDb = client.db('test');
+    const db = new MongoDataProvider(mongoDb, client, { disableTransactions: true });
+    var remult = new Remult(db);
+    const entity = class {
+        id = 0;
+        title = '';
+    };
+    describeClass(entity, Entity("testNoTrans"), { id: Fields.number(), title: Fields.string() });
+    const repo = remult.repo(entity);
+    for (const item of await repo.find()) {
+        await repo.delete(item);
+    }
+    await repo.insert({ id: 1, title: "a" });
+    try {
+        await db.transaction(async () => {
+            await repo.insert({ id: 2, title: "b" });
+            throw new Error();
+        });
+    }
+    catch { }
+    expect(await repo.count()).toBe(2);
+});
+import '../shared-tests';

package/{src → esm/core/src}/backend-tests/my-test.backend-spec.d.ts

@@ -1 +1 @@
-export {};
+export {};

package/esm/core/src/backend-tests/my-test.backend-spec.js

@@ -0,0 +1,197 @@
+import { Remult } from "../context";
+import { Entity, Fields } from "../remult3";
+import { KnexDataProvider } from '../../remult-knex';
+import { config } from 'dotenv';
+import { testKnexPGSqlImpl, testMongo, testPostgresImplementation } from "./backend-database-test-setup.backend-spec";
+import { entityWithValidations } from "../shared-tests/entityWithValidations";
+import { PostgresDataProvider } from "../../postgres";
+import { MongoDataProvider } from "../../remult-mongo";
+import { SqlDatabase } from "../data-providers/sql-database";
+import { dbNamesOf } from "../filter/filter-consumer-bridge-to-sql-request";
+import { RemultAsyncLocalStorage } from "../../src/context";
+import { remult } from "../remult-proxy";
+import { describeClass } from "../remult3/DecoratorReplacer";
+import { AsyncLocalStorage } from "async_hooks";
+config();
+testPostgresImplementation("default order by", async ({ createEntity }) => {
+    let s = await entityWithValidations.create4RowsInDp(createEntity);
+    await s.update(1, { name: "updated name" });
+    expect((await s.find()).map(x => x.myId)).toEqual([1, 2, 3, 4]);
+}, false);
+testKnexPGSqlImpl("default order by", async ({ createEntity }) => {
+    let s = await entityWithValidations.create4RowsInDp(createEntity);
+    await s.update(1, { name: "updated name" });
+    expect((await s.find()).map(x => x.myId)).toEqual([1, 2, 3, 4]);
+}, false);
+testPostgresImplementation("sql filter", async ({ createEntity }) => {
+    let s = await entityWithValidations.create4RowsInDp(createEntity);
+    expect((await s.find({
+        where: SqlDatabase.rawFilter(async (build) => {
+            build.sql = s.metadata.fields.myId.options.dbName + ' in (1,3)';
+        })
+    })).length).toBe(2);
+}, false);
+testPostgresImplementation("sql filter2", async ({ createEntity }) => {
+    let s = await entityWithValidations.create4RowsInDp(createEntity);
+    expect((await s.find({
+        where: {
+            $or: [
+                SqlDatabase.rawFilter(async (build) => {
+                    build.sql = s.metadata.fields.myId.options.dbName + ' in (1,3)';
+                }),
+                {
+                    myId: 2
+                }
+            ]
+        }
+    })).length).toBe(3);
+}, false);
+testKnexPGSqlImpl("knex filter", async ({ createEntity }) => {
+    let s = await entityWithValidations.create4RowsInDp(createEntity);
+    expect((await s.find({
+        where: KnexDataProvider.rawFilter(async () => {
+            return build => build.whereIn(s.metadata.fields.myId.options.dbName, [1, 3]);
+        })
+    })).length).toBe(2);
+}, false);
+testKnexPGSqlImpl("knex filter2", async ({ createEntity }) => {
+    let s = await entityWithValidations.create4RowsInDp(createEntity);
+    expect((await s.find({
+        where: {
+            $or: [KnexDataProvider.rawFilter(async () => {
+                    return build => build.whereIn(s.metadata.fields.myId.options.dbName, [1, 3]);
+                }), {
+                    myId: 4
+                }]
+        }
+    })).length).toBe(3);
+}, false);
+testPostgresImplementation("ensure schema with dbNames that have quotes", async ({ remult }) => {
+    const db = SqlDatabase.getDb(remult);
+    const entityName = 'test_naming';
+    await db.execute("Drop table if exists " + entityName);
+    await db.execute(`create table ${entityName}(id int,"createdAt" Date)`);
+    const ent = class {
+        id = 0;
+        createdAt = new Date();
+        oneMoreColumn = 0;
+    };
+    describeClass(ent, Entity(entityName), {
+        id: Fields.integer(),
+        createdAt: Fields.createdAt({ dbName: '"createdAt"' }),
+        oneMoreColumn: Fields.integer()
+    });
+    await db.ensureSchema([remult.repo(ent).metadata]);
+    await remult.repo(ent).insert({ id: 1, oneMoreColumn: 8 });
+    expect((await remult.repo(ent).findFirst()).createdAt.getFullYear()).toBe(new Date().getFullYear());
+}, false);
+testPostgresImplementation("work with native sql", async ({ remult, createEntity }) => {
+    const repo = await entityWithValidations.create4RowsInDp(createEntity);
+    const sql = SqlDatabase.getDb(remult);
+    const r = await sql.execute("select count(*) as c from " + repo.metadata.options.dbName);
+    expect(r.rows[0].c).toBe('4');
+}, false);
+testPostgresImplementation("work with native sql2", async ({ remult, createEntity }) => {
+    const repo = await entityWithValidations.create4RowsInDp(createEntity);
+    const sql = PostgresDataProvider.getDb(remult);
+    const r = await sql.query("select count(*) as c from " + repo.metadata.options.dbName);
+    expect(r.rows[0].c).toBe('4');
+}, false);
+testPostgresImplementation("work with native sql3", async ({ remult, createEntity }) => {
+    const repo = await entityWithValidations.create4RowsInDp(createEntity);
+    await SqlDatabase.getDb(remult)._getSourceSql().transaction(async (x) => {
+        const sql = PostgresDataProvider.getDb(new Remult(new SqlDatabase(x)));
+        const r = await sql.query("select count(*) as c from " + repo.metadata.options.dbName);
+        expect(r.rows[0].c).toBe('4');
+    });
+}, false);
+testKnexPGSqlImpl("work with native knex", async ({ remult, createEntity }) => {
+    const repo = await entityWithValidations.create4RowsInDp(createEntity);
+    const knex = KnexDataProvider.getDb(remult);
+    const r = await knex(repo.metadata.options.dbName).count();
+    expect(r[0].count).toBe('4');
+}, false);
+testKnexPGSqlImpl("work with native knex2", async ({ remult, createEntity }) => {
+    const repo = await entityWithValidations.create4RowsInDp(createEntity);
+    await (remult.dataProvider).transaction(async (db) => {
+        const sql = KnexDataProvider.getDb(new Remult(db));
+        const r = await sql(repo.metadata.options.dbName).count();
+        expect(r[0].count).toBe('4');
+    });
+}, false);
+testKnexPGSqlImpl("work with native knex3", async ({ remult, createEntity }) => {
+    const repo = await entityWithValidations.create4RowsInDp(createEntity);
+    const knex = KnexDataProvider.getDb(remult);
+    const t = await dbNamesOf(repo);
+    const r = await knex((await t).$entityName).select(t.myId, t.name);
+    expect(r.length).toBe(4);
+}, false);
+testMongo("work with native mongo", async ({ remult, createEntity }) => {
+    const repo = await entityWithValidations.create4RowsInDp(createEntity);
+    const mongo = MongoDataProvider.getDb(remult);
+    const r = await (await mongo.db.collection(repo.metadata.options.dbName)).countDocuments();
+    expect(r).toBe(4);
+}, false);
+testKnexPGSqlImpl("knex with filter", async ({ remult, createEntity }) => {
+    const repo = await entityWithValidations.create4RowsInDp(createEntity);
+    const knex = KnexDataProvider.getDb(remult);
+    const e = await dbNamesOf(repo);
+    const r = await knex(e.$entityName).count().where(await KnexDataProvider.filterToRaw(repo, { myId: [1, 3] }));
+    expect(r[0].count).toBe('2');
+}, false);
+testMongo("work with native mongo and condition", async ({ remult, createEntity }) => {
+    const repo = await entityWithValidations.create4RowsInDp(createEntity);
+    const mongo = MongoDataProvider.getDb(remult);
+    const r = await (await mongo.db.collection(repo.metadata.options.dbName)).countDocuments(await MongoDataProvider.filterToRaw(repo, { myId: [1, 2] }));
+    expect(r).toBe(2);
+}, false);
+it("test async hooks and static remult", async () => {
+    let gotException = true;
+    try {
+        RemultAsyncLocalStorage.instance.getRemult();
+        gotException = false;
+    }
+    catch { }
+    expect(gotException).toBe(true);
+    RemultAsyncLocalStorage.instance = new RemultAsyncLocalStorage(new AsyncLocalStorage());
+    try {
+        expect(RemultAsyncLocalStorage.instance.getRemult()).toBe(undefined);
+        RemultAsyncLocalStorage.enable();
+        try {
+            remult.isAllowed(false);
+            gotException = false;
+        }
+        catch { }
+        expect(gotException).toBe(true);
+        const promises = [];
+        RemultAsyncLocalStorage.instance.run(new Remult(), () => {
+            remult.user = { id: 'noam' };
+            promises.push(new Promise(res => {
+                setTimeout(() => {
+                    expect(remult.user.id).toBe('noam');
+                    res({});
+                }, 10);
+            }));
+            RemultAsyncLocalStorage.instance.run(new Remult(), () => {
+                remult.user = { id: 'yoni' };
+                promises.push(new Promise(res => {
+                    setTimeout(() => {
+                        expect(remult.user.id).toBe('yoni');
+                        res({});
+                    }, 10);
+                }));
+            });
+            promises.push(new Promise(res => {
+                setTimeout(() => {
+                    expect(remult.user.id).toBe('noam');
+                    res({});
+                }, 10);
+            }));
+        });
+        await Promise.all(promises);
+    }
+    finally {
+        RemultAsyncLocalStorage.disable();
+        RemultAsyncLocalStorage.instance = new RemultAsyncLocalStorage(undefined);
+    }
+});

package/esm/core/src/backend-tests/test-http-server.backend-spec.d.ts

@@ -0,0 +1 @@
+export {};

package/esm/core/src/backend-tests/test-http-server.backend-spec.js

@@ -0,0 +1,167 @@
+import axios from 'axios';
+import { remult } from '../remult-proxy';
+import { Categories } from '../tests/remult-3-entities';
+import { Task } from '../../../test-servers/shared/Task';
+import { remultFresh } from '../../remult-fresh';
+import { InMemoryDataProvider } from '../data-providers/in-memory-database';
+import { RemultAsyncLocalStorage } from '../context';
+const servers = {
+    koa: "koa",
+    fastify: "fastify",
+    express: "express",
+    mw: "mw",
+    fresh: "fresh",
+    mwc: "mwc",
+    svelteKit: 'svelteKit',
+    nextApp: "nextApp"
+};
+remult.apiClient.url = 'http://localhost:3003/api';
+let path = remult.apiClient.url + '/tasks';
+const environments = [
+// ["optine", 3006],
+//["nest", 3001],
+// ["next", 3000],
+// [servers.nextApp, 3010],
+// [servers.koa, 3002],
+// [servers.fastify, 3003],
+// [servers.express, 3004],
+// [servers.mw, 3005],
+// [servers.mwc, 3007],
+//  [servers.fresh, 8000],
+// [servers.svelteKit, 5173],
+];
+function test(name, test, ...ignoreList) {
+    for (const [env, port] of environments) {
+        if (ignoreList?.includes(env))
+            continue;
+        const theTest = async () => {
+            remult.apiClient.url = `http://localhost:${port}/api`;
+            path = remult.apiClient.url + '/tasks';
+            await test();
+        };
+        const testName = env + ` ${port}: ${name}`;
+        fit(testName, theTest);
+    }
+}
+test("works", async () => {
+    const repo = await create3Tasks();
+    const tasks = await repo.find({ where: { completed: true } });
+    expect(tasks.length).toBe(1);
+    await repo.save({ ...tasks[0], completed: false });
+    expect(await repo.count({ completed: true })).toBe(0);
+});
+test("test multiple items", async () => {
+    const repo = await create3Tasks();
+    expect(await repo.count({
+        title: { "!=": ["a", "c"] }
+    })).toBe(1);
+});
+test("validation", async () => {
+    const r = await create3Tasks();
+    let err = undefined;
+    try {
+        await r.insert({ "title": "" });
+    }
+    catch (error) {
+        err = error;
+    }
+    expect(err).toEqual({
+        message: "Title: Should not be empty",
+        httpStatusCode: 400,
+        modelState: {
+            title: "Should not be empty"
+        }
+    });
+});
+test("forbidden", async () => {
+    let err = undefined;
+    try {
+        await Task.testForbidden();
+    }
+    catch (error) {
+        err = error;
+    }
+    expect(err.httpStatusCode).toEqual(403);
+});
+test("test static remult", async () => {
+    const r = await create3Tasks();
+    expect(await Task.testStaticRemult()).toBe(3);
+}, servers.fresh, servers.mwc);
+test("test injected remult", async () => {
+    const r = await create3Tasks();
+    expect(await Task.testInjectedRemult()).toBe(3);
+});
+test("test http 404", async () => {
+    const repo = create3Tasks();
+    const task = await (await repo).findFirst();
+    let result = await axios.get(path + "/" + task.id);
+    expect(result.data.id).toBe(task.id);
+    expect(result.status).toBe(200);
+    let error = undefined;
+    try {
+        result = await axios.get(path + "/123");
+    }
+    catch (err) {
+        error = err;
+    }
+    expect(error.response.status).toBe(404);
+});
+test("test http 201", async () => {
+    let result = await axios.post(path, { title: "z", id: "" });
+    expect(result.data.title).toBe("z");
+    expect(result.status).toBe(201);
+    result = await axios.delete(path + "/" + result.data.id);
+    expect(result.status).toBe(204);
+});
+test("test regular api call", async () => {
+    await create3Tasks();
+    let result = await axios.get(remult.apiClient.url + "/test");
+    expect(result.data.result).toBe(3);
+});
+class FreshResponseTest {
+    body;
+    init;
+    constructor(body, init) {
+        this.body = body;
+        this.init = init;
+    }
+    static json(data, init) {
+        return new this(data, init);
+    }
+}
+it("test fresh", async () => {
+    try {
+        const api = remultFresh({
+            entities: [Categories],
+            dataProvider: new InMemoryDataProvider(),
+            rootPath: '/api',
+            logApiEndPoints: false
+        }, FreshResponseTest);
+        const r = await api.handle({
+            url: '/api/Categories',
+            json() {
+                return undefined;
+            },
+            method: "get"
+        }, {
+            next() {
+                return undefined;
+            },
+        });
+        expect(r.body).toEqual([]);
+    }
+    finally {
+        RemultAsyncLocalStorage.disable();
+    }
+});
+async function create3Tasks() {
+    remult.apiClient.httpClient = axios;
+    const taskRepo = remult.repo(Task);
+    for (const task of await taskRepo.find()) {
+        await taskRepo.delete(task);
+    }
+    expect(await taskRepo.count()).toBe(0);
+    await taskRepo.insert([{ title: "a" }, { title: "b", completed: true }, { title: "c" }]);
+    expect(await taskRepo.count()).toBe(3);
+    return taskRepo;
+}

package/esm/core/src/buildRestDataProvider.d.ts

@@ -0,0 +1,31 @@
+import { RestDataProviderHttpProvider } from "./data-interfaces";
+import { RestDataProviderHttpProviderUsingFetch } from './data-providers/rest-data-provider';
+export declare function buildRestDataProvider(provider: ExternalHttpProvider | typeof fetch): RestDataProviderHttpProviderUsingFetch | RestDataProviderHttpProvider;
+export declare function isExternalHttpProvider(item: any): boolean;
+export declare class HttpProviderBridgeToRestDataProviderHttpProvider implements RestDataProviderHttpProvider {
+    private http;
+    constructor(http: ExternalHttpProvider);
+    post(url: string, data: any): Promise<any>;
+    delete(url: string): Promise<void>;
+    put(url: string, data: any): Promise<any>;
+    get(url: string): Promise<any>;
+}
+export declare function retry<T>(what: () => Promise<T>): Promise<T>;
+export declare function toPromise<T>(p: Promise<T> | {
+    toPromise(): Promise<T>;
+}): Promise<any>;
+export declare function processHttpException(ex: any): Promise<any>;
+export interface ExternalHttpProvider {
+    post(url: string, data: any): Promise<any> | {
+        toPromise(): Promise<any>;
+    };
+    delete(url: string): Promise<void> | {
+        toPromise(): Promise<void>;
+    };
+    put(url: string, data: any): Promise<any> | {
+        toPromise(): Promise<any>;
+    };
+    get(url: string): Promise<any> | {
+        toPromise(): Promise<any>;
+    };
+}