remult 0.17.0-exp.7 → 0.17.0-exp.8

package/README.md

@@ -3,6 +3,7 @@
     <img src="https://github.com/remult/remult/raw/master/docs/.vuepress/public/logo.png" width="140" height="140">
   </a>
   <h1>Remult</h1>
+  <p>A CRUD framework for full-stack TypeScript</p>
 	<a href="https://circleci.com/gh/remult/remult/tree/master" rel="nofollow">
 		<img alt="CircleCI" src="https://circleci.com/gh/remult/remult/tree/master.svg?style=shield">
 	</a>
@@ -24,14 +25,29 @@
   <a href="https://twitter.com/intent/tweet?text=Remult%20-%20open-source%20CRUD%20framework%20for%20full-stack%20TypeScript%0A%0A%40remultjs%0A&url=https%3A%2F%2Fgithub.com%2Fremult%2Fremult">
     <img alt="Twitter URL" src="https://img.shields.io/twitter/url?style=social&url=https%3A%2F%2Ftwitter.com%2Fintent%2Ftweet%3Ftext%3DRemult%2520-%2520open-source%2520CRUD%2520framework%2520for%2520full-stack%2520TypeScript%250A%250A%2540remultjs%250A%26url%3Dhttps%253A%252F%252Fgithub.com%252Fremult%252Fremult">
   </a>
-	<a href="https://twitter.com/remultjs" rel="nofollow">
-	  <img alt="Twitter Follow" src="https://img.shields.io/twitter/url.svg?label=Follow%20%40remultjs&style=social&url=https%3A%2F%2Ftwitter.com%2FRemultJs">
-	</a>
 </div>
+
+
+<br/>
+
+<div align="center">
+  <a href="#getting-started">Getting Started</a> |
+  <a href="#documentation">Documentation</a> |
+  <a href="#example-apps">Example Apps</a>
+</div>
+
 <hr/>
+<br/>
 
-[Getting Started](#getting-started) | [Documentation](#documentation) |
-[Example Apps](#example-apps)
+<a href="https://www.youtube.com/watch?v=rEoScmSVNUE" target="_blank">
+  <p align="center">
+    <img src="https://github.com/remult/remult/raw/master/static/images/video-thumbnail.jpg" alt="Video thumbnail"  />
+  </p>
+</a>
+
+<a href="https://www.youtube.com/watch?v=rEoScmSVNUE" target="_blank">
+  <p align="center">Watch code demo on YouTube here (14 mins)</p>
+</a>
 
 ## What is Remult?
 
@@ -39,6 +55,13 @@
 as a single source of truth for your API, frontend type-safe API client and
 backend ORM**.
 
+* :zap: Zero-boilerplate CRUD API routes with paging, sorting, and filtering for Express / Fastify / Next.js / NestJS / Koa / others...
+* :ok_hand: Fullstack type-safety for API queries, mutations and RPC, without code generation
+* :sparkles: Input validation, defined once, runs both on the backend and on the frontend for best UX
+* :lock: Fine-grained code-based API authorization
+* :relieved: Incrementally adoptable
+* :rocket: Production ready
+
 ### Status
 
 Remult is **production-ready** and, in fact, used in production apps since 2018.

package/core/assign.d.ts

@@ -0,0 +1 @@
+export declare function assign<T>(item: T, valuesToSet: Partial<T>): T;

package/core/assign.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assign = void 0;
+function assign(item, valuesToSet) {
+    if (valuesToSet)
+        Object.assign(item, valuesToSet);
+    return item;
+}
+exports.assign = assign;

package/core/classType.d.ts

@@ -0,0 +1,3 @@
+export declare type ClassType<T> = {
+    new (...args: any[]): T;
+};

package/core/classType.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/core/graphql.d.ts

@@ -0,0 +1,5 @@
+import { RemultServer } from "./server/expressBridge";
+export declare function remultGraphql(api: RemultServer): {
+    rootValue: {};
+    schema: string;
+};

package/core/graphql.js

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.remultGraphql = void 0;
+var tslib_1 = require("tslib");
+var _1 = require(".");
+var context_1 = require("./src/context");
+var remult3_1 = require("./src/remult3");
+var data_api_1 = require("./src/data-api");
+function remultGraphql(api) {
+    var e_1, _a;
+    var _this = this;
+    var _b;
+    var r = new _1.Remult();
+    var types = '';
+    var query = '';
+    var root = {};
+    var _loop_1 = function (e) {
+        var e_2, _a, e_3, _b, e_4, _c, e_5, _d;
+        var meta = r.repo(e).metadata;
+        var fields = '';
+        var filterFields = '';
+        var key = remult3_1.getEntityKey(e);
+        if (key) {
+            try {
+                for (var _e = (e_2 = void 0, tslib_1.__values(meta.fields)), _f = _e.next(); !_f.done; _f = _e.next()) {
+                    var f = _f.value;
+                    {
+                        var type = "String";
+                        switch (f.valueType) {
+                            case Boolean:
+                                type = "Boolean";
+                            case Number:
+                                {
+                                    if (((_b = f.valueConverter) === null || _b === void 0 ? void 0 : _b.fieldTypeInDb) == 'integer')
+                                        type = "Int";
+                                    else
+                                        type = "Float";
+                                }
+                        }
+                        fields += "\n\t" + f.key + ":" + type;
+                        try {
+                            for (var _g = (e_3 = void 0, tslib_1.__values(["", "_ne"])), _h = _g.next(); !_h.done; _h = _g.next()) {
+                                var operator = _h.value;
+                                filterFields += "\n\t" + f.key + operator + ":" + type;
+                            }
+                        }
+                        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                        finally {
+                            try {
+                                if (_h && !_h.done && (_b = _g.return)) _b.call(_g);
+                            }
+                            finally { if (e_3) throw e_3.error; }
+                        }
+                        if (f.valueType === String || f.valueType === Number)
+                            try {
+                                for (var _j = (e_4 = void 0, tslib_1.__values(["_gt", "_gte", "_lt", "_lte"])), _k = _j.next(); !_k.done; _k = _j.next()) {
+                                    var operator = _k.value;
+                                    filterFields += "\n\t" + f.key + operator + ":" + type;
+                                }
+                            }
+                            catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                            finally {
+                                try {
+                                    if (_k && !_k.done && (_c = _j.return)) _c.call(_j);
+                                }
+                                finally { if (e_4) throw e_4.error; }
+                            }
+                        if (f.valueType === String)
+                            try {
+                                for (var _l = (e_5 = void 0, tslib_1.__values(["_st", "_contains"])), _m = _l.next(); !_m.done; _m = _l.next()) {
+                                    var operator = _m.value;
+                                    filterFields += "\n\t" + f.key + operator + ":" + type;
+                                }
+                            }
+                            catch (e_5_1) { e_5 = { error: e_5_1 }; }
+                            finally {
+                                try {
+                                    if (_m && !_m.done && (_d = _l.return)) _d.call(_l);
+                                }
+                                finally { if (e_5) throw e_5.error; }
+                            }
+                        if (f.allowNull)
+                            filterFields += "\n\t" + f.key + "_null:Boolean";
+                        filterFields += "\n\t" + f.key + "_in:[" + type + "]";
+                    }
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (_f && !_f.done && (_a = _e.return)) _a.call(_e);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+            types += "type " + key + "{" + fields + "\n}\n";
+            types += "input " + key + "Filter{" + filterFields + "\n\tOR:[" + key + "Filter]\n}\n";
+            query += "\n\t" + key + "(options: options, filter:" + key + "Filter): [" + key + "]";
+            root[key] = function (_a, req) {
+                var options = _a.options, filter = _a.filter;
+                return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                    var remult, repo, dApi, result, err;
+                    return tslib_1.__generator(this, function (_b) {
+                        switch (_b.label) {
+                            case 0: return [4 /*yield*/, api.getRemult(req)];
+                            case 1:
+                                remult = _b.sent();
+                                repo = remult.repo(e);
+                                dApi = new data_api_1.DataApi(repo, remult);
+                                return [4 /*yield*/, dApi.getArray({
+                                        success: function (x) { return result = x; },
+                                        created: undefined,
+                                        deleted: undefined,
+                                        error: function (x) { return err = x; },
+                                        forbidden: function () { return err = 'forbidden'; },
+                                        notFound: function () { return err = 'not found'; },
+                                        progress: undefined
+                                    }, {
+                                        get: function (key) {
+                                            if (options)
+                                                switch (key) {
+                                                    case "_limit":
+                                                        return options.limit;
+                                                    case "_page":
+                                                        return options.page;
+                                                    case "_sort":
+                                                        return options.sort;
+                                                    case "_order":
+                                                        return options.order;
+                                                }
+                                        }
+                                    }, filter)];
+                            case 2:
+                                _b.sent();
+                                if (err)
+                                    throw err;
+                                return [2 /*return*/, result];
+                        }
+                    });
+                });
+            };
+        }
+    };
+    try {
+        for (var allEntities_1 = tslib_1.__values(context_1.allEntities), allEntities_1_1 = allEntities_1.next(); !allEntities_1_1.done; allEntities_1_1 = allEntities_1.next()) {
+            var e = allEntities_1_1.value;
+            _loop_1(e);
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (allEntities_1_1 && !allEntities_1_1.done && (_a = allEntities_1.return)) _a.call(allEntities_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    if (query.length > 0) {
+        query = "type Query {" + query + "\n}";
+    }
+    return {
+        rootValue: root,
+        schema: "\ninput options{\n    limit:Int\n    page:Int\n    sort:String\n    order:String\n}\n" + types + "\n" + query + "\n"
+    };
+}
+exports.remultGraphql = remultGraphql;

package/core/index.d.ts

@@ -0,0 +1,25 @@
+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 { describeClass } from './src/remult3/DecoratorReplacer';
+export { EntityOptions } from './src/entity';
+export { DataProvider, EntityDataProvider, EntityDataProviderFindOptions, ErrorInfo, RestDataProviderHttpProvider } from './src/data-interfaces';
+export { SqlCommand, SqlImplementation, SqlResult } from './src/sql-command';
+export { FieldMetadata, FieldOptions, FieldValidator, ValueConverter, ValueListItem, // reconsider, maybe it should go to remult angular as the abstraction ?
+ValueOrExpression } from './src/column-interfaces';
+export { RestDataProvider } from './src/data-providers/rest-data-provider';
+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 { 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 { 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';

package/core/index.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.remult = exports.ValueConverters = exports.Validators = exports.UrlBuilder = exports.FilterConsumerBridgeToSqlRequest = exports.Filter = exports.CompoundIdField = exports.OneToMany = exports.Sort = exports.IdEntity = exports.EventSource = exports.isBackend = exports.Remult = exports.Allow = exports.ProgressListener = exports.BackendMethod = exports.Controller = exports.JsonDataProvider = exports.CustomSqlFilterBuilder = exports.SqlDatabase = exports.WebSqlDataProvider = exports.ArrayEntityDataProvider = exports.InMemoryDataProvider = exports.RestDataProvider = exports.describeClass = exports.CaptionTransformer = exports.ValueListInfo = exports.getValueList = exports.ValueListFieldType = exports.getEntityRef = exports.getFields = exports.FieldType = exports.ControllerBase = exports.EntityBase = exports.Entity = exports.Fields = exports.Field = void 0;
+/*
+ * Public API Surface of remult
+ */
+var remult3_1 = require("./src/remult3");
+Object.defineProperty(exports, "Field", { enumerable: true, get: function () { return remult3_1.Field; } });
+Object.defineProperty(exports, "Fields", { enumerable: true, get: function () { return remult3_1.Fields; } });
+Object.defineProperty(exports, "Entity", { enumerable: true, get: function () { return remult3_1.Entity; } });
+Object.defineProperty(exports, "EntityBase", { enumerable: true, get: function () { return remult3_1.EntityBase; } });
+Object.defineProperty(exports, "ControllerBase", { enumerable: true, get: function () { return remult3_1.ControllerBase; } });
+Object.defineProperty(exports, "FieldType", { enumerable: true, get: function () { return remult3_1.FieldType; } });
+Object.defineProperty(exports, "getFields", { enumerable: true, get: function () { return remult3_1.getFields; } });
+Object.defineProperty(exports, "getEntityRef", { enumerable: true, get: function () { return remult3_1.getEntityRef; } });
+Object.defineProperty(exports, "ValueListFieldType", { enumerable: true, get: function () { return remult3_1.ValueListFieldType; } });
+Object.defineProperty(exports, "getValueList", { enumerable: true, get: function () { return remult3_1.getValueList; } });
+Object.defineProperty(exports, "ValueListInfo", { enumerable: true, get: function () { return remult3_1.ValueListInfo; } });
+Object.defineProperty(exports, "CaptionTransformer", { enumerable: true, get: function () { return remult3_1.CaptionTransformer; } });
+var DecoratorReplacer_1 = require("./src/remult3/DecoratorReplacer");
+Object.defineProperty(exports, "describeClass", { enumerable: true, get: function () { return DecoratorReplacer_1.describeClass; } });
+var rest_data_provider_1 = require("./src/data-providers/rest-data-provider"); //V
+Object.defineProperty(exports, "RestDataProvider", { enumerable: true, get: function () { return rest_data_provider_1.RestDataProvider; } });
+var in_memory_database_1 = require("./src/data-providers/in-memory-database"); //V
+Object.defineProperty(exports, "InMemoryDataProvider", { enumerable: true, get: function () { return in_memory_database_1.InMemoryDataProvider; } });
+var array_entity_data_provider_1 = require("./src/data-providers/array-entity-data-provider"); //V
+Object.defineProperty(exports, "ArrayEntityDataProvider", { enumerable: true, get: function () { return array_entity_data_provider_1.ArrayEntityDataProvider; } });
+var web_sql_data_provider_1 = require("./src/data-providers/web-sql-data-provider"); //V
+Object.defineProperty(exports, "WebSqlDataProvider", { enumerable: true, get: function () { return web_sql_data_provider_1.WebSqlDataProvider; } });
+var sql_database_1 = require("./src/data-providers/sql-database"); //V
+Object.defineProperty(exports, "SqlDatabase", { enumerable: true, get: function () { return sql_database_1.SqlDatabase; } });
+var filter_consumer_bridge_to_sql_request_1 = require("./src/filter/filter-consumer-bridge-to-sql-request");
+Object.defineProperty(exports, "CustomSqlFilterBuilder", { enumerable: true, get: function () { return filter_consumer_bridge_to_sql_request_1.CustomSqlFilterBuilder; } });
+var json_data_provider_1 = require("./src/data-providers/json-data-provider"); //V
+Object.defineProperty(exports, "JsonDataProvider", { enumerable: true, get: function () { return json_data_provider_1.JsonDataProvider; } });
+//export * from './src/data-api'; //reconsider if to make internal
+var server_action_1 = require("./src/server-action");
+Object.defineProperty(exports, "Controller", { enumerable: true, get: function () { return server_action_1.Controller; } });
+Object.defineProperty(exports, "BackendMethod", { enumerable: true, get: function () { return server_action_1.BackendMethod; } });
+Object.defineProperty(exports, "ProgressListener", { enumerable: true, get: function () { return server_action_1.ProgressListener; } });
+var context_1 = require("./src/context");
+Object.defineProperty(exports, "Allow", { enumerable: true, get: function () { return context_1.Allow; } });
+Object.defineProperty(exports, "Remult", { enumerable: true, get: function () { return context_1.Remult; } });
+Object.defineProperty(exports, "isBackend", { enumerable: true, get: function () { return context_1.isBackend; } });
+Object.defineProperty(exports, "EventSource", { enumerable: true, get: function () { return context_1.EventSource; } });
+var id_entity_1 = require("./src/id-entity");
+Object.defineProperty(exports, "IdEntity", { enumerable: true, get: function () { return id_entity_1.IdEntity; } });
+var sort_1 = require("./src/sort");
+Object.defineProperty(exports, "Sort", { enumerable: true, get: function () { return sort_1.Sort; } });
+var column_1 = require("./src/column");
+Object.defineProperty(exports, "OneToMany", { enumerable: true, get: function () { return column_1.OneToMany; } });
+Object.defineProperty(exports, "CompoundIdField", { enumerable: true, get: function () { return column_1.CompoundIdField; } });
+var filter_interfaces_1 = require("./src/filter/filter-interfaces");
+Object.defineProperty(exports, "Filter", { enumerable: true, get: function () { return filter_interfaces_1.Filter; } });
+var filter_consumer_bridge_to_sql_request_2 = require("./src/filter/filter-consumer-bridge-to-sql-request");
+Object.defineProperty(exports, "FilterConsumerBridgeToSqlRequest", { enumerable: true, get: function () { return filter_consumer_bridge_to_sql_request_2.FilterConsumerBridgeToSqlRequest; } });
+var urlBuilder_1 = require("./urlBuilder");
+Object.defineProperty(exports, "UrlBuilder", { enumerable: true, get: function () { return urlBuilder_1.UrlBuilder; } });
+var validators_1 = require("./src/validators");
+Object.defineProperty(exports, "Validators", { enumerable: true, get: function () { return validators_1.Validators; } });
+var valueConverters_1 = require("./src/valueConverters");
+Object.defineProperty(exports, "ValueConverters", { enumerable: true, get: function () { return valueConverters_1.ValueConverters; } });
+var remult_proxy_1 = require("./src/remult-proxy");
+Object.defineProperty(exports, "remult", { enumerable: true, get: function () { return remult_proxy_1.remult; } });

package/core/inputTypes.d.ts

@@ -0,0 +1,9 @@
+export declare class InputTypes {
+    static number: string;
+    static date: string;
+    static checkbox: string;
+    static password: string;
+    static email: string;
+    static tel: string;
+    static time: string;
+}

package/core/inputTypes.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InputTypes = void 0;
+var InputTypes = /** @class */ (function () {
+    function InputTypes() {
+    }
+    InputTypes.number = 'number';
+    InputTypes.date = 'date';
+    InputTypes.checkbox = 'checkbox';
+    InputTypes.password = 'password';
+    InputTypes.email = 'email';
+    InputTypes.tel = 'tel';
+    InputTypes.time = "time";
+    return InputTypes;
+}());
+exports.InputTypes = InputTypes;

package/core/postgres/index.d.ts

@@ -0,0 +1,2 @@
+export * from './postgres-data-provider';
+export * from './schema-builder';

package/core/postgres/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./postgres-data-provider"), exports);
+tslib_1.__exportStar(require("./schema-builder"), exports);

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

@@ -0,0 +1,28 @@
+import { PoolConfig, QueryResult } from 'pg';
+import { EntityMetadata } from '../src/remult3';
+import { SqlCommand, SqlImplementation } from '../src/sql-command';
+import { SqlDatabase } from '../src/data-providers/sql-database';
+export interface PostgresPool extends PostgresCommandSource {
+    connect(): Promise<PostgresClient>;
+}
+export interface PostgresClient extends PostgresCommandSource {
+    release(): void;
+}
+export declare class PostgresDataProvider implements SqlImplementation {
+    private pool;
+    entityIsUsedForTheFirstTime(entity: EntityMetadata): Promise<void>;
+    getLimitSqlSyntax(limit: number, offset: number): string;
+    createCommand(): SqlCommand;
+    constructor(pool: PostgresPool);
+    transaction(action: (dataProvider: SqlImplementation) => Promise<void>): Promise<void>;
+}
+export interface PostgresCommandSource {
+    query(queryText: string, values?: any[]): Promise<QueryResult>;
+}
+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/core/postgres/postgres-data-provider.js

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preparePostgresQueueStorage = exports.createPostgresConnection = exports.PostgresDataProvider = void 0;
+var tslib_1 = require("tslib");
+var pg_1 = require("pg");
+var context_1 = require("../src/context");
+var schema_builder_1 = require("./schema-builder");
+var sql_database_1 = require("../src/data-providers/sql-database");
+var PostgresDataProvider = /** @class */ (function () {
+    function PostgresDataProvider(pool) {
+        this.pool = pool;
+    }
+    PostgresDataProvider.prototype.entityIsUsedForTheFirstTime = function (entity) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                return [2 /*return*/];
+            });
+        });
+    };
+    PostgresDataProvider.prototype.getLimitSqlSyntax = function (limit, offset) {
+        return ' limit ' + limit + ' offset ' + offset;
+    };
+    PostgresDataProvider.prototype.createCommand = function () {
+        return new PostgresBridgeToSQLCommand(this.pool);
+    };
+    PostgresDataProvider.prototype.transaction = function (action) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var client, err_1;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.pool.connect()];
+                    case 1:
+                        client = _a.sent();
+                        _a.label = 2;
+                    case 2:
+                        _a.trys.push([2, 6, 8, 10]);
+                        return [4 /*yield*/, client.query('BEGIN')];
+                    case 3:
+                        _a.sent();
+                        return [4 /*yield*/, action({
+                                createCommand: function () { return new PostgresBridgeToSQLCommand(client); },
+                                entityIsUsedForTheFirstTime: this.entityIsUsedForTheFirstTime,
+                                transaction: function () { throw "nested transactions not allowed"; },
+                                getLimitSqlSyntax: this.getLimitSqlSyntax
+                            })];
+                    case 4:
+                        _a.sent();
+                        return [4 /*yield*/, client.query('COMMIT')];
+                    case 5:
+                        _a.sent();
+                        return [3 /*break*/, 10];
+                    case 6:
+                        err_1 = _a.sent();
+                        return [4 /*yield*/, client.query('ROLLBACK')];
+                    case 7:
+                        _a.sent();
+                        throw err_1;
+                    case 8: return [4 /*yield*/, client.release()];
+                    case 9:
+                        _a.sent();
+                        return [7 /*endfinally*/];
+                    case 10: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return PostgresDataProvider;
+}());
+exports.PostgresDataProvider = PostgresDataProvider;
+var PostgresBridgeToSQLCommand = /** @class */ (function () {
+    function PostgresBridgeToSQLCommand(source) {
+        this.source = source;
+        this.values = [];
+    }
+    PostgresBridgeToSQLCommand.prototype.addParameterAndReturnSqlToken = function (val) {
+        this.values.push(val);
+        return '$' + this.values.length;
+    };
+    PostgresBridgeToSQLCommand.prototype.execute = function (sql) {
+        return this.source.query(sql, this.values).then(function (r) { return new PostgresBridgeToSQLQueryResult(r); });
+    };
+    return PostgresBridgeToSQLCommand;
+}());
+var PostgresBridgeToSQLQueryResult = /** @class */ (function () {
+    function PostgresBridgeToSQLQueryResult(r) {
+        this.r = r;
+        this.rows = r.rows;
+    }
+    PostgresBridgeToSQLQueryResult.prototype.getColumnKeyInResultForIndexInSelect = function (index) {
+        return this.r.fields[index].name;
+    };
+    return PostgresBridgeToSQLQueryResult;
+}());
+function createPostgresConnection(options) {
+    return tslib_1.__awaiter(this, void 0, void 0, function () {
+        var config, db, remult;
+        return tslib_1.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!options)
+                        options = {};
+                    config = {};
+                    if (options.configuration)
+                        if (options.configuration == "heroku") {
+                            config = {
+                                connectionString: process.env.DATABASE_URL,
+                                ssl: process.env.NODE_ENV !== "production" && !options.sslInDev ? false : {
+                                    rejectUnauthorized: false
+                                }
+                            };
+                        }
+                        else
+                            config = options.configuration;
+                    else {
+                        if (!options.connectionString)
+                            options.connectionString = process.env.DATABASE_URL;
+                    }
+                    if (!config.connectionString && options.connectionString) {
+                        config.connectionString = options.connectionString;
+                    }
+                    db = new sql_database_1.SqlDatabase(new PostgresDataProvider(new pg_1.Pool(config)));
+                    remult = new context_1.Remult();
+                    remult.dataProvider = (db);
+                    if (!(options.autoCreateTables === undefined || options.autoCreateTables)) return [3 /*break*/, 2];
+                    return [4 /*yield*/, schema_builder_1.verifyStructureOfAllEntities(db, remult)];
+                case 1:
+                    _a.sent();
+                    _a.label = 2;
+                case 2: return [2 /*return*/, db];
+            }
+        });
+    });
+}
+exports.createPostgresConnection = createPostgresConnection;
+function preparePostgresQueueStorage(sql) {
+    return tslib_1.__awaiter(this, void 0, void 0, function () {
+        var c, JobsInQueueEntity, e;
+        return tslib_1.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    c = new context_1.Remult();
+                    c.dataProvider = (sql);
+                    return [4 /*yield*/, Promise.resolve().then(function () { return require('../server/expressBridge'); })];
+                case 1:
+                    JobsInQueueEntity = (_a.sent()).JobsInQueueEntity;
+                    e = c.repo(JobsInQueueEntity);
+                    return [4 /*yield*/, new schema_builder_1.PostgresSchemaBuilder(sql).createIfNotExist(e.metadata)];
+                case 2:
+                    _a.sent();
+                    return [4 /*yield*/, new schema_builder_1.PostgresSchemaBuilder(sql).verifyAllColumns(e.metadata)];
+                case 3:
+                    _a.sent();
+                    return [4 /*yield*/, Promise.resolve().then(function () { return require('../server/expressBridge'); })];
+                case 4: return [2 /*return*/, new (_a.sent()).EntityQueueStorage(c.repo(JobsInQueueEntity))];
+            }
+        });
+    });
+}
+exports.preparePostgresQueueStorage = preparePostgresQueueStorage;

package/core/postgres/schema-builder.d.ts

@@ -0,0 +1,15 @@
+import { FieldMetadata } from '../src/column-interfaces';
+import { Remult } from '../src/context';
+import { SqlDatabase } from '../src/data-providers/sql-database';
+import { EntityMetadata } from '../src/remult3';
+export declare function postgresColumnSyntax(x: FieldMetadata, dbName: string): string;
+export declare function verifyStructureOfAllEntities(db: SqlDatabase, remult: Remult): Promise<void>;
+export declare class PostgresSchemaBuilder {
+    private pool;
+    verifyStructureOfAllEntities(remult: Remult): Promise<void>;
+    createIfNotExist(entity: EntityMetadata): Promise<void>;
+    addColumnIfNotExist<T extends EntityMetadata>(entity: T, c: ((e: T) => FieldMetadata)): Promise<void>;
+    verifyAllColumns<T extends EntityMetadata>(entity: T): Promise<void>;
+    additionalWhere: string;
+    constructor(pool: SqlDatabase, schema?: string);
+}