remult 0.22.2 → 0.22.3

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

@@ -1,6 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

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

package/esm/core/server/initAsyncHooks.js

@@ -1,9 +0,0 @@
-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

@@ -1,2 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

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

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

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

package/esm/core/src/__RowsOfDataForTesting.js

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

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

@@ -1,6 +0,0 @@
-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

@@ -1,147 +0,0 @@
-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/esm/core/src/backend-tests/my-test.backend-spec.js

@@ -1,197 +0,0 @@
-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

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

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

@@ -1,167 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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>;
-    };
-}