remult 0.17.3 → 0.18.0

package/SseSubscriptionServer.d.ts

@@ -0,0 +1,23 @@
+import { GenericResponse } from './server/index';
+import { Remult } from './src/context';
+import { SubscriptionServer } from './src/live-query/SubscriptionServer';
+export declare class SseSubscriptionServer implements SubscriptionServer {
+    private canUserConnectToChannel?;
+    constructor(canUserConnectToChannel?: (channel: string, remult: Remult) => boolean);
+    publishMessage<T>(channel: string, message: any): Promise<void>;
+}
+export interface ResponseRequiredForSSE {
+    write(data: string): void;
+    writeHead(status: number, headers: any): void;
+    flush?(): void;
+}
+export declare class clientConnection {
+    response: GenericResponse & ResponseRequiredForSSE;
+    channels: Record<string, boolean>;
+    close(): void;
+    closed: boolean;
+    write(eventData: string, eventType?: string): void;
+    connectionId: any;
+    constructor(response: GenericResponse & ResponseRequiredForSSE);
+    sendLiveMessage(): void;
+}

package/SseSubscriptionServer.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clientConnection = exports.SseSubscriptionServer = void 0;
+var tslib_1 = require("tslib");
+var uuid_1 = require("uuid");
+var SseSubscriptionClient_1 = require("./src/live-query/SseSubscriptionClient");
+var SseSubscriptionServer = /** @class */ (function () {
+    function SseSubscriptionServer(canUserConnectToChannel) {
+        this.canUserConnectToChannel = canUserConnectToChannel;
+        //@internal
+        this.connections = [];
+        //@internal
+        this.debugMessageFileSaver = function (id, channel, message) { };
+        //@internal
+        this.debugFileSaver = function () { };
+        if (!this.canUserConnectToChannel) {
+            this.canUserConnectToChannel = function () { return true; };
+        }
+    }
+    //@internal
+    SseSubscriptionServer.prototype.subscribeToChannel = function (_a, res, remult, remove) {
+        var e_1, _b;
+        var channel = _a.channel, clientId = _a.clientId;
+        if (remove === void 0) { remove = false; }
+        try {
+            for (var _c = tslib_1.__values(this.connections), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var c = _d.value;
+                if (c.connectionId === clientId) {
+                    if (this.canUserConnectToChannel(channel, remult)) {
+                        if (remove)
+                            delete c.channels[channel];
+                        else
+                            c.channels[channel] = true;
+                        res.success("ok");
+                        this.debug();
+                        return;
+                    }
+                    else {
+                        res.forbidden();
+                        this.debug();
+                        return;
+                    }
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        res.success(SseSubscriptionClient_1.ConnectionNotFoundError);
+    };
+    SseSubscriptionServer.prototype.publishMessage = function (channel, message) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var data, _a, _b, sc;
+            var e_2, _c;
+            return tslib_1.__generator(this, function (_d) {
+                data = JSON.stringify({ channel: channel, data: message });
+                try {
+                    for (_a = tslib_1.__values(this.connections), _b = _a.next(); !_b.done; _b = _a.next()) {
+                        sc = _b.value;
+                        if (sc.channels[channel]) {
+                            this.debugMessageFileSaver(sc.connectionId, channel, message);
+                            sc.write(data);
+                        }
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    //@internal
+    SseSubscriptionServer.prototype.openHttpServerStream = function (req, res) {
+        var _this = this;
+        res.writeHead(200, {
+            'Content-Type': 'text/event-stream',
+            'Cache-Control': 'no-cache',
+            'Connection': 'keep-alive'
+        });
+        var cc = new clientConnection(res);
+        //const lastEventId = req.headers['last-event-id'];
+        this.connections.push(cc);
+        this.debug();
+        //@ts-ignore
+        req.on("close", function () {
+            cc.close();
+            _this.connections = _this.connections.filter(function (s) { return s !== cc; });
+            _this.debug();
+        });
+        return cc;
+    };
+    //@internal
+    SseSubscriptionServer.prototype.debug = function () {
+        this.debugFileSaver(this.connections.map(function (x) { return ({
+            id: x.connectionId,
+            channels: x.channels
+        }); }));
+    };
+    return SseSubscriptionServer;
+}());
+exports.SseSubscriptionServer = SseSubscriptionServer;
+var clientConnection = /** @class */ (function () {
+    function clientConnection(response) {
+        this.response = response;
+        this.channels = {};
+        this.closed = false;
+        this.connectionId = uuid_1.v4();
+        this.write(this.connectionId, "connectionId");
+        this.sendLiveMessage();
+    }
+    clientConnection.prototype.close = function () {
+        this.closed = true;
+    };
+    clientConnection.prototype.write = function (eventData, eventType) {
+        if (eventType === void 0) { eventType = "message"; }
+        var event = "event:" + eventType;
+        // if (id != undefined)
+        //     event += "\nid:" + id;
+        this.response.write(event + "\ndata:" + eventData + "\n\n");
+        if (this.response.flush)
+            this.response.flush();
+    };
+    clientConnection.prototype.sendLiveMessage = function () {
+        var _this = this;
+        if (this.closed)
+            return;
+        this.write("", "keep-alive");
+        setTimeout(function () {
+            _this.sendLiveMessage();
+        }, 45000);
+    };
+    return clientConnection;
+}());
+exports.clientConnection = clientConnection;

package/ably.d.ts

@@ -0,0 +1,13 @@
+import type * as Ably from '../../node_modules/ably';
+import type { SubscriptionServer } from './src/live-query/SubscriptionServer';
+import type { SubscriptionClient, SubscriptionClientConnection } from './src/live-query/SubscriptionChannel';
+export declare class AblySubscriptionClient implements SubscriptionClient {
+    private ably;
+    constructor(ably: Ably.Types.RealtimePromise);
+    openConnection(onReconnect: VoidFunction): Promise<SubscriptionClientConnection>;
+}
+export declare class AblySubscriptionServer implements SubscriptionServer {
+    private ably;
+    constructor(ably: Ably.Types.RestPromise);
+    publishMessage<T>(channel: string, message: T): Promise<void>;
+}

package/ably.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AblySubscriptionServer = exports.AblySubscriptionClient = void 0;
+var tslib_1 = require("tslib");
+var AblySubscriptionClient = /** @class */ (function () {
+    function AblySubscriptionClient(ably) {
+        this.ably = ably;
+    }
+    AblySubscriptionClient.prototype.openConnection = function (onReconnect) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return tslib_1.__generator(this, function (_a) {
+                return [2 /*return*/, {
+                        close: function () {
+                            // Since we did not open the connection, we do not close it
+                        },
+                        subscribe: function (channel, handler) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                            var myHandler;
+                            var _this = this;
+                            return tslib_1.__generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        myHandler = function (y) { return handler(y.data); };
+                                        return [4 /*yield*/, this.ably.channels.get(channel).subscribe(function (y) { return myHandler(y); })];
+                                    case 1:
+                                        _a.sent();
+                                        return [2 /*return*/, function () {
+                                                myHandler = function () { };
+                                                _this.ably.channels.get(channel).unsubscribe();
+                                            }];
+                                }
+                            });
+                        }); }
+                    }];
+            });
+        });
+    };
+    return AblySubscriptionClient;
+}());
+exports.AblySubscriptionClient = AblySubscriptionClient;
+var AblySubscriptionServer = /** @class */ (function () {
+    function AblySubscriptionServer(ably) {
+        this.ably = ably;
+    }
+    AblySubscriptionServer.prototype.publishMessage = function (channel, message) {
+        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*/, this.ably.channels.get(channel).publish({ data: message })];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return AblySubscriptionServer;
+}());
+exports.AblySubscriptionServer = AblySubscriptionServer;

package/esm/SseSubscriptionServer.d.ts

@@ -0,0 +1,23 @@
+import { GenericResponse } from './server/index';
+import { Remult } from './src/context';
+import { SubscriptionServer } from './src/live-query/SubscriptionServer';
+export declare class SseSubscriptionServer implements SubscriptionServer {
+    private canUserConnectToChannel?;
+    constructor(canUserConnectToChannel?: (channel: string, remult: Remult) => boolean);
+    publishMessage<T>(channel: string, message: any): Promise<void>;
+}
+export interface ResponseRequiredForSSE {
+    write(data: string): void;
+    writeHead(status: number, headers: any): void;
+    flush?(): void;
+}
+export declare class clientConnection {
+    response: GenericResponse & ResponseRequiredForSSE;
+    channels: Record<string, boolean>;
+    close(): void;
+    closed: boolean;
+    write(eventData: string, eventType?: string): void;
+    connectionId: any;
+    constructor(response: GenericResponse & ResponseRequiredForSSE);
+    sendLiveMessage(): void;
+}

package/esm/SseSubscriptionServer.js

@@ -0,0 +1,102 @@
+import { v4 as uuid } from 'uuid';
+import { ConnectionNotFoundError } from './src/live-query/SseSubscriptionClient';
+export class SseSubscriptionServer {
+    constructor(canUserConnectToChannel) {
+        this.canUserConnectToChannel = canUserConnectToChannel;
+        //@internal
+        this.connections = [];
+        //@internal
+        this.debugMessageFileSaver = (id, channel, message) => { };
+        //@internal
+        this.debugFileSaver = () => { };
+        if (!this.canUserConnectToChannel) {
+            this.canUserConnectToChannel = () => true;
+        }
+    }
+    //@internal
+    subscribeToChannel({ channel, clientId }, res, remult, remove = false) {
+        for (const c of this.connections) {
+            if (c.connectionId === clientId) {
+                if (this.canUserConnectToChannel(channel, remult)) {
+                    if (remove)
+                        delete c.channels[channel];
+                    else
+                        c.channels[channel] = true;
+                    res.success("ok");
+                    this.debug();
+                    return;
+                }
+                else {
+                    res.forbidden();
+                    this.debug();
+                    return;
+                }
+            }
+        }
+        res.success(ConnectionNotFoundError);
+    }
+    async publishMessage(channel, message) {
+        const data = JSON.stringify({ channel, data: message });
+        for (const sc of this.connections) {
+            if (sc.channels[channel]) {
+                this.debugMessageFileSaver(sc.connectionId, channel, message);
+                sc.write(data);
+            }
+        }
+    }
+    //@internal
+    openHttpServerStream(req, res) {
+        res.writeHead(200, {
+            'Content-Type': 'text/event-stream',
+            'Cache-Control': 'no-cache',
+            'Connection': 'keep-alive'
+        });
+        const cc = new clientConnection(res);
+        //const lastEventId = req.headers['last-event-id'];
+        this.connections.push(cc);
+        this.debug();
+        //@ts-ignore
+        req.on("close", () => {
+            cc.close();
+            this.connections = this.connections.filter(s => s !== cc);
+            this.debug();
+        });
+        return cc;
+    }
+    //@internal
+    debug() {
+        this.debugFileSaver(this.connections.map(x => ({
+            id: x.connectionId,
+            channels: x.channels
+        })));
+    }
+}
+export class clientConnection {
+    constructor(response) {
+        this.response = response;
+        this.channels = {};
+        this.closed = false;
+        this.connectionId = uuid();
+        this.write(this.connectionId, "connectionId");
+        this.sendLiveMessage();
+    }
+    close() {
+        this.closed = true;
+    }
+    write(eventData, eventType = "message") {
+        let event = "event:" + eventType;
+        // if (id != undefined)
+        //     event += "\nid:" + id;
+        this.response.write(event + "\ndata:" + eventData + "\n\n");
+        if (this.response.flush)
+            this.response.flush();
+    }
+    sendLiveMessage() {
+        if (this.closed)
+            return;
+        this.write("", "keep-alive");
+        setTimeout(() => {
+            this.sendLiveMessage();
+        }, 45000);
+    }
+}

package/esm/ably.d.ts

@@ -0,0 +1,13 @@
+import type * as Ably from '../../node_modules/ably';
+import type { SubscriptionServer } from './src/live-query/SubscriptionServer';
+import type { SubscriptionClient, SubscriptionClientConnection } from './src/live-query/SubscriptionChannel';
+export declare class AblySubscriptionClient implements SubscriptionClient {
+    private ably;
+    constructor(ably: Ably.Types.RealtimePromise);
+    openConnection(onReconnect: VoidFunction): Promise<SubscriptionClientConnection>;
+}
+export declare class AblySubscriptionServer implements SubscriptionServer {
+    private ably;
+    constructor(ably: Ably.Types.RestPromise);
+    publishMessage<T>(channel: string, message: T): Promise<void>;
+}

package/esm/ably.js

@@ -0,0 +1,28 @@
+export class AblySubscriptionClient {
+    constructor(ably) {
+        this.ably = ably;
+    }
+    async openConnection(onReconnect) {
+        return {
+            close: () => {
+                // Since we did not open the connection, we do not close it
+            },
+            subscribe: async (channel, handler) => {
+                let myHandler = (y) => handler(y.data);
+                await this.ably.channels.get(channel).subscribe(y => myHandler(y));
+                return () => {
+                    myHandler = () => { };
+                    this.ably.channels.get(channel).unsubscribe();
+                };
+            }
+        };
+    }
+}
+export class AblySubscriptionServer {
+    constructor(ably) {
+        this.ably = ably;
+    }
+    async publishMessage(channel, message) {
+        await this.ably.channels.get(channel).publish({ data: message });
+    }
+}

package/esm/index.d.ts

@@ -1,4 +1,5 @@
-export { Field, Fields, StringFieldOptions, FieldsMetadata, Entity, EntityBase, ControllerBase, FieldRef, IdFieldRef, FieldsRef, EntityMetadata, EntityOrderBy, EntityFilter, FindOptions, QueryResult, QueryOptions, Repository, FieldType, FindFirstOptions, ComparisonValueFilter, ValueFilter, IdFilter, ContainsStringValueFilter, getFields, EntityRef, getEntityRef, SortSegments, ValueListFieldType, getValueList, ValueListFieldOptions, ValueListInfo, OmitEB, Paginator, CaptionTransformer } from './src/remult3';
+export { Field, Fields, FieldsMetadata, Entity, EntityBase, ControllerBase, FieldRef, IdFieldRef, FieldsRef, EntityMetadata, EntityOrderBy, EntityFilter, FindOptions, QueryResult, QueryOptions, Repository, FieldType, FindFirstOptions, ComparisonValueFilter, ValueFilter, IdFilter, ContainsStringValueFilter, getFields, EntityRef, getEntityRef, SortSegments, ValueListFieldType, getValueList, ValueListFieldOptions, ValueListInfo, OmitEB, Paginator, CaptionTransformer, LiveQuery, LiveQueryChangeInfo } from './src/remult3';
+export { StringFieldOptions } from './src/remult3/RepositoryImplementation';
 export { describeClass } from './src/remult3/DecoratorReplacer';
 export { EntityOptions } from './src/entity';
 export { DataProvider, EntityDataProvider, EntityDataProviderFindOptions, ErrorInfo, RestDataProviderHttpProvider } from './src/data-interfaces';
@@ -10,16 +11,18 @@ export { InMemoryDataProvider } from './src/data-providers/in-memory-database';
 export { ArrayEntityDataProvider } from './src/data-providers/array-entity-data-provider';
 export { WebSqlDataProvider } from './src/data-providers/web-sql-data-provider';
 export { SqlDatabase, } from './src/data-providers/sql-database';
-export { CustomSqlFilterObject, CustomSqlFilterBuilder } from './src/filter/filter-consumer-bridge-to-sql-request';
+export { CustomSqlFilterObject, CustomSqlFilterBuilder, dbNamesOf } from './src/filter/filter-consumer-bridge-to-sql-request';
 export { JsonDataProvider, JsonEntityStorage } from './src/data-providers/json-data-provider';
 export { Controller, BackendMethodOptions, BackendMethod, ProgressListener } from './src/server-action';
-export { Allowed, Allow, Remult, RemultContext, ApiClient, isBackend, AllowedForInstance, EventDispatcher, EventSource, ExternalHttpProvider, Unobserve, UserInfo } from './src/context';
+export { Allowed, Allow, Remult, RemultContext, ApiClient, isBackend, AllowedForInstance, EventDispatcher, EventSource, Unobserve, UserInfo } from './src/context';
+export { ExternalHttpProvider } from './src/buildRestDataProvider';
 export { IdEntity } from './src/id-entity';
 export { SortSegment, Sort } from './src/sort';
 export { OneToMany, CompoundIdField } from './src/column';
 export { Filter } from './src/filter/filter-interfaces';
-export { FilterConsumerBridgeToSqlRequest } from './src/filter/filter-consumer-bridge-to-sql-request';
 export { UrlBuilder } from './urlBuilder';
 export { Validators } from './src/validators';
 export { ValueConverters } from './src/valueConverters';
 export { remult } from './src/remult-proxy';
+export { SubscriptionServer, LiveQueryStorage, StoredQuery, InMemoryLiveQueryStorage } from "./src/live-query/SubscriptionServer";
+export { SubscriptionListener, SubscriptionClientConnection, SubscriptionClient, SubscriptionChannel, LiveQueryChange, Unsubscribe } from './src/live-query/SubscriptionChannel';

package/esm/index.js

@@ -8,7 +8,7 @@ export { InMemoryDataProvider } from './src/data-providers/in-memory-database';
 export { ArrayEntityDataProvider } from './src/data-providers/array-entity-data-provider'; //V
 export { WebSqlDataProvider } from './src/data-providers/web-sql-data-provider'; //V
 export { SqlDatabase, } from './src/data-providers/sql-database'; //V
-export { CustomSqlFilterBuilder } from './src/filter/filter-consumer-bridge-to-sql-request';
+export { CustomSqlFilterBuilder, dbNamesOf } from './src/filter/filter-consumer-bridge-to-sql-request';
 export { JsonDataProvider } from './src/data-providers/json-data-provider'; //V
 //export * from './src/data-api'; //reconsider if to make internal
 export { Controller, BackendMethod, ProgressListener } from './src/server-action';
@@ -17,8 +17,10 @@ export { IdEntity } from './src/id-entity';
 export { Sort } from './src/sort';
 export { OneToMany, CompoundIdField } from './src/column';
 export { Filter } from './src/filter/filter-interfaces';
-export { FilterConsumerBridgeToSqlRequest } from './src/filter/filter-consumer-bridge-to-sql-request';
 export { UrlBuilder } from './urlBuilder';
 export { Validators } from './src/validators';
 export { ValueConverters } from './src/valueConverters';
 export { remult } from './src/remult-proxy';
+//export { getId } from './src/remult3/getId';
+export { InMemoryLiveQueryStorage } from "./src/live-query/SubscriptionServer";
+export { SubscriptionChannel } from './src/live-query/SubscriptionChannel';

package/esm/live-query/data-provider-live-query-storage.d.ts

@@ -0,0 +1,23 @@
+import { Storage, DataProvider } from "../src/data-interfaces";
+import { LiveQueryStorage, StoredQuery } from "../src/live-query/SubscriptionServer";
+import { EntityBase, Repository } from "../src/remult3";
+export declare class DataProviderLiveQueryStorage implements LiveQueryStorage, Storage {
+    repo: Promise<Repository<LiveQueryStorageEntity>>;
+    dataProvider: Promise<DataProvider>;
+    constructor(dataProvider: DataProvider | Promise<DataProvider> | (() => Promise<DataProvider | undefined>));
+    ensureSchema(): Promise<void>;
+    add({ id, entityKey, data }: StoredQuery): Promise<void>;
+    remove(queryId: string): Promise<void>;
+    forEach(entityKey: string, callback: (args: {
+        query: StoredQuery;
+        setData(data: any): Promise<void>;
+    }) => Promise<void>): Promise<void>;
+    keepAliveAndReturnUnknownQueryIds(queryIds: string[]): Promise<string[]>;
+}
+declare class LiveQueryStorageEntity extends EntityBase {
+    id: string;
+    entityKey: string;
+    data: any;
+    lastUsedIso: string;
+}
+export {};

package/esm/live-query/data-provider-live-query-storage.js

@@ -0,0 +1,78 @@
+import { __decorate, __metadata } from "tslib";
+import { initDataProvider } from "../server/initDataProvider";
+import { Remult } from "../src/context";
+import { Entity, EntityBase, Fields } from "../src/remult3";
+export class DataProviderLiveQueryStorage {
+    constructor(dataProvider) {
+        this.dataProvider = initDataProvider(dataProvider);
+        this.repo = this.dataProvider.then(dp => new Remult(dp).repo(LiveQueryStorageEntity));
+    }
+    async ensureSchema() {
+        await (await this.dataProvider).ensureSchema([(await this.repo).metadata]);
+    }
+    async add({ id, entityKey, data }) {
+        await this.repo.then(async (repo) => {
+            const q = await repo.findId(id, { createIfNotFound: true });
+            await q.assign({ entityKey, data }).save();
+        });
+    }
+    async remove(queryId) {
+        await this.repo.then(repo => repo.delete(queryId)).catch(() => { });
+    }
+    async forEach(entityKey, callback) {
+        const repo = await this.repo;
+        let d = new Date();
+        d.setMinutes(d.getMinutes() - 5);
+        const iso = d.toISOString();
+        for (const query of await repo.find({ where: { entityKey } })) {
+            if (query.lastUsedIso < iso)
+                await repo.delete(query);
+            else {
+                await callback({
+                    query, setData: async (data) => {
+                        query.data = data;
+                        await repo.save(query);
+                    },
+                });
+            }
+        }
+    }
+    async keepAliveAndReturnUnknownQueryIds(queryIds) {
+        const repo = await this.repo;
+        for (const query of await repo.find({ where: { id: queryIds } })) {
+            query.lastUsedIso = new Date().toISOString();
+            await repo.save(query);
+            queryIds = queryIds.filter(x => x !== query.id);
+        }
+        return queryIds;
+    }
+}
+let LiveQueryStorageEntity = class LiveQueryStorageEntity extends EntityBase {
+    constructor() {
+        super(...arguments);
+        this.id = '';
+        this.entityKey = '';
+        this.lastUsedIso = new Date().toISOString();
+    }
+};
+__decorate([
+    Fields.string(),
+    __metadata("design:type", Object)
+], LiveQueryStorageEntity.prototype, "id", void 0);
+__decorate([
+    Fields.string(),
+    __metadata("design:type", Object)
+], LiveQueryStorageEntity.prototype, "entityKey", void 0);
+__decorate([
+    Fields.object(),
+    __metadata("design:type", Object)
+], LiveQueryStorageEntity.prototype, "data", void 0);
+__decorate([
+    Fields.string(),
+    __metadata("design:type", Object)
+], LiveQueryStorageEntity.prototype, "lastUsedIso", void 0);
+LiveQueryStorageEntity = __decorate([
+    Entity(undefined, {
+        dbName: 'remult_live_query_storage'
+    })
+], LiveQueryStorageEntity);

package/esm/myLog.d.ts

@@ -0,0 +1 @@
+export declare function writeToLog(what: any): Promise<void>;

package/esm/myLog.js

@@ -0,0 +1,5 @@
+export async function writeToLog(what) {
+    if (typeof what !== "string")
+        what = JSON.stringify(what, undefined, 2);
+    (await (import('fs'))).appendFileSync('./tmp/test.log', what + '\n');
+}

package/esm/postgres/postgres-data-provider.d.ts

@@ -1,4 +1,5 @@
-import { PoolConfig, QueryResult } from 'pg';
+import { ClientBase, PoolConfig, QueryResult } from 'pg';
+import { Remult } from '../src/context';
 import { EntityMetadata } from '../src/remult3';
 import { SqlCommand, SqlImplementation } from '../src/sql-command';
 import { SqlDatabase } from '../src/data-providers/sql-database';
@@ -10,10 +11,12 @@ export interface PostgresClient extends PostgresCommandSource {
 }
 export declare class PostgresDataProvider implements SqlImplementation {
     private pool;
+    static getDb(remult?: Remult): ClientBase;
     entityIsUsedForTheFirstTime(entity: EntityMetadata): Promise<void>;
     getLimitSqlSyntax(limit: number, offset: number): string;
     createCommand(): SqlCommand;
     constructor(pool: PostgresPool);
+    ensureSchema(entities: EntityMetadata<any>[]): Promise<void>;
     transaction(action: (dataProvider: SqlImplementation) => Promise<void>): Promise<void>;
 }
 export interface PostgresCommandSource {
@@ -23,6 +26,5 @@ export declare function createPostgresConnection(options?: {
     connectionString?: string;
     sslInDev?: boolean;
     configuration?: "heroku" | PoolConfig;
-    autoCreateTables?: boolean;
 }): Promise<SqlDatabase>;
 export declare function preparePostgresQueueStorage(sql: SqlDatabase): Promise<import("../server/expressBridge").EntityQueueStorage>;

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

@@ -1,11 +1,19 @@
 import { Pool } from 'pg';
 import { Remult } from '../src/context';
-import { PostgresSchemaBuilder, verifyStructureOfAllEntities } from './schema-builder';
+import { PostgresSchemaBuilder } from './schema-builder';
 import { SqlDatabase } from '../src/data-providers/sql-database';
 export class PostgresDataProvider {
     constructor(pool) {
         this.pool = pool;
     }
+    static getDb(remult) {
+        const sql = SqlDatabase.getDb(remult);
+        const me = sql._getSourceSql();
+        if (!me.pool) {
+            throw "the data provider is not a PostgresDataProvider";
+        }
+        return me.pool;
+    }
     async entityIsUsedForTheFirstTime(entity) {
     }
     getLimitSqlSyntax(limit, offset) {
@@ -14,6 +22,11 @@ export class PostgresDataProvider {
     createCommand() {
         return new PostgresBridgeToSQLCommand(this.pool);
     }
+    async ensureSchema(entities) {
+        var db = new SqlDatabase(this);
+        var sb = new PostgresSchemaBuilder(db);
+        await sb.ensureSchema(entities);
+    }
     async transaction(action) {
         let client = await this.pool.connect();
         try {
@@ -22,7 +35,9 @@ export class PostgresDataProvider {
                 createCommand: () => new PostgresBridgeToSQLCommand(client),
                 entityIsUsedForTheFirstTime: this.entityIsUsedForTheFirstTime,
                 transaction: () => { throw "nested transactions not allowed"; },
-                getLimitSqlSyntax: this.getLimitSqlSyntax
+                getLimitSqlSyntax: this.getLimitSqlSyntax,
+                //@ts-ignore
+                pool: client
             });
             await client.query('COMMIT');
         }
@@ -82,8 +97,6 @@ export async function createPostgresConnection(options) {
     const db = new SqlDatabase(new PostgresDataProvider(new Pool(config)));
     let remult = new Remult();
     remult.dataProvider = (db);
-    if (options.autoCreateTables === undefined || options.autoCreateTables)
-        await verifyStructureOfAllEntities(db, remult);
     return db;
 }
 export async function preparePostgresQueueStorage(sql) {
@@ -91,7 +104,6 @@ export async function preparePostgresQueueStorage(sql) {
     c.dataProvider = (sql);
     let JobsInQueueEntity = (await import('../server/expressBridge')).JobsInQueueEntity;
     let e = c.repo(JobsInQueueEntity);
-    await new PostgresSchemaBuilder(sql).createIfNotExist(e.metadata);
-    await new PostgresSchemaBuilder(sql).verifyAllColumns(e.metadata);
+    await sql.ensureSchema([e.metadata]);
     return new (await import('../server/expressBridge')).EntityQueueStorage(c.repo(JobsInQueueEntity));
 }