remult 0.14.4 → 0.14.7-esm.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Noam Honig, Yoni Rapoport and contributors.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/{readme.md → README.md}

@@ -25,51 +25,40 @@
 	<img alt="Twitter Follow" src="https://img.shields.io/twitter/follow/remultjs?style=social">
 	</a>
 </div>
+<hr/>
+
+[Getting Started](#getting-started) | [Documentation](#documentation) | [Example App](#example-app)
 
 ## What is Remult?
 
-**Remult** is a full-stack CRUD framework that uses your TypeScript model types to provide:
+**Remult** is a full-stack CRUD framework that uses your **TypeScript entities as a single source of truth for your API, frontend type-safe API client and backend ORM**.
 
-* Secure REST API (highly configurable)
-* Type-safe frontend API client
-* Type-safe backend query builder
+### Status
 
-#### Remult :heart: Code Sharing
+Remult is **production-ready** and, in fact, used in production apps since 2017. However, we’re keeping the major version at zero so we can use community feedback to finalize the v1 API.
 
-With model types shared between frontend and backend code, Remult can **enforce data validation and constraints, defined once, both in the front-end and within back-end API routes**.
+## Motivation
 
-## Getting started
-The best way to learn Remult is by following a tutorial of a simple Todo web app with a Node.js Express backend. 
+Full-stack web development is (still) too complicated. **Simple CRUD, a common requirement of any business application, should be simple to build, maintain, and extend** when the need arises.
 
-* [Tutorial with React](https://remult.dev/tutorials/react/) 
-* [Tutorial with Angular](https://remult.dev/tutorials/angular/)
-* [Tutorial with Vue](https://remult.dev/tutorials/vue/)
-* [Tutorial with Next.js](https://remult.dev/tutorials/react-next/)
+Remult abstracts away repetitive, boilerplate, error-prone, and poorly designed code on the one hand, and enables total flexibility and control on the other. **Remult let you write TypeScript code you can follow and safely refactor**, and fits nicely into any existing or new project by being minimalistic and completely unopinionated regarding the developer’s choice of other frameworks and tools.
+
+Other frameworks tend to fall into either too much abstraction (no-code, low-code, BaaS) or partial abstraction (MVC frameworks, GraphQL, ORMs, API generators, code generators), and tend to be opinionated regarding the development tool-chain, deployment environment, configuration/conventions or DSL. Remult attempts to strike a better balance.
 
 ## Installation
+
+The *remult* package is one and the same for both the frontend bundle and the backend. Install it once for a monolith project or per-repo in a monorepo.
+
 ```sh
 npm i remult
 ```
 
 ## Usage
 
-### Setup API backend using a Node.js Express middleware
-```ts
-import express from 'express';
-import { remultExpress } from 'remult/remult-express';
-
-const port = 3001;
-const app = express();
-
-app.use(remultExpress());
-
-app.listen(port, () => {
-  console.log(`Example API listening at http://localhost:${port}`);
-});
-```
-
 ### Define model classes
 ```ts
+// shared/product.ts
+
 import { Entity, Fields } from 'remult';
 
 @Entity('products', {
@@ -84,6 +73,26 @@ export class Product {
 }
 ```
 
+### Setup API backend using an Express middleware
+```ts
+// backend/index.ts
+
+import express from 'express';
+import { remultExpress } from 'remult/remult-express';
+import { Product } from '../shared/product';
+
+const port = 3001;
+const app = express();
+
+app.use(remultExpress({
+  entities: [Product]
+}));
+
+app.listen(port, () => {
+  console.log(`Example API listening at http://localhost:${port}`);
+});
+```
+
 ### :rocket: API Ready
 ```sh
 > curl http://localhost:3001/api/products
@@ -93,12 +102,19 @@ export class Product {
 
 ### Find and manipulate data in type-safe frontend code
 ```ts
+// frontend/code.ts
+
+import { Remult } from 'remult';
+import { Product } from '../shared/product';
+
+const remult = new Remult();
+
 async function increasePriceOfTofu(priceIncrease: number) {
   const productsRepo = remult.repo(Product);
 
-  const product = await productsRepo.findFirst({ name: 'Tofu' });
+  const product = await productsRepo.findFirst({ name: 'Tofu' }); // filter is passed through API request all the way to the db
   product.unitPrice += priceIncrease;
-  productsRepo.save(product);
+  productsRepo.save(product); // mutation request updates the db with no boilerplate code
 }
 ```
 
@@ -108,7 +124,7 @@ async function increasePriceOfTofu(priceIncrease: number) {
 static async increasePriceOfTofu(priceIncrease: number, remult?: Remult) {
   const productsRepo = remult!.repo(Product);
 
-  const product = await productsRepo.findFirst({ name: 'Tofu' });
+  const product = await productsRepo.findFirst({ name: 'Tofu' }); // use Remult in the backend as an ORM
   product.unitPrice += priceIncrease;
   productsRepo.save(product);
 }
@@ -184,6 +200,28 @@ export class Article {
 }
 ```
 
+## What about complex CRUD?
+
+While simple CRUD shouldn’t require any backend coding, using Remult means having the ability to handle any complex scenario by controlling the backend in numerous ways:
+
+* Backend computed (read-only) fields - from simple [expressions](https://remult.dev/docs/ref_field.html#serverexpression) to complex data lookups or even direct db access (SQL)
+* Custom side-effects with [entity lifecycle hooks](https://remult.dev/docs/ref_entity.html#saving) (before/after saving/deleting)
+* Backend only updatable fields (e.g. “last updated at”)
+* Many-to-one [relations](https://remult.dev/docs/entity-relations.html) with [lazy/eager loading](https://remult.dev/docs/lazy-loading-of-related-entities.html)
+* Roll-your-own type-safe endpoints with [Backend Methods](https://remult.dev/docs/backendMethods.html)
+* Roll-your-own low-level endpoints (Express, Fastify, koa, others…)
+
+## Getting started
+The best way to learn Remult is by following a tutorial of a simple Todo web app with a Node.js Express backend. 
+
+* [Tutorial with React](https://remult.dev/tutorials/react/) 
+* [Tutorial with Angular](https://remult.dev/tutorials/angular/)
+* [Tutorial with Vue](https://remult.dev/tutorials/vue/)
+* [Tutorial with Next.js](https://remult.dev/tutorials/react-next/)
+
+## Documentation
+The [documentation](https://remult.dev/docs) covers the main features of Remult. However, it is still a work-in-progress.
+
 ## Example App
 
 [CRM demo](https://github.com/remult/crm-demo) with a React + [MUI](https://mui.com) front-end and Postgres database.

package/esm/assign.d.ts

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

package/esm/assign.js

@@ -0,0 +1,5 @@
+export function assign(item, valuesToSet) {
+    if (valuesToSet)
+        Object.assign(item, valuesToSet);
+    return item;
+}

package/esm/classType.d.ts

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

package/esm/classType.js

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

package/esm/graphql.d.ts

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

package/esm/graphql.js

@@ -0,0 +1,102 @@
+import { Remult } from ".";
+import { allEntities } from "./src/context";
+import { getEntityKey } from "./src/remult3";
+import { DataApi } from "./src/data-api";
+export function remultGraphql(api) {
+    let r = new Remult();
+    let types = '';
+    let query = '';
+    let root = {};
+    for (const e of allEntities) {
+        let meta = r.repo(e).metadata;
+        let fields = '';
+        let filterFields = '';
+        let key = getEntityKey(e);
+        if (key) {
+            for (const f of meta.fields) {
+                {
+                    let type = "String";
+                    switch (f.valueType) {
+                        case Boolean:
+                            type = "Boolean";
+                        case Number:
+                            {
+                                if (f.valueConverter?.fieldTypeInDb == 'integer')
+                                    type = "Int";
+                                else
+                                    type = "Float";
+                            }
+                    }
+                    fields += "\n\t" + f.key + ":" + type;
+                    for (const operator of ["", "_ne"]) {
+                        filterFields += "\n\t" + f.key + operator + ":" + type;
+                    }
+                    if (f.valueType === String || f.valueType === Number)
+                        for (const operator of ["_gt", "_gte", "_lt", "_lte"]) {
+                            filterFields += "\n\t" + f.key + operator + ":" + type;
+                        }
+                    if (f.valueType === String)
+                        for (const operator of ["_st", "_contains"]) {
+                            filterFields += "\n\t" + f.key + operator + ":" + type;
+                        }
+                    if (f.allowNull)
+                        filterFields += "\n\t" + f.key + "_null:Boolean";
+                    filterFields += "\n\t" + f.key + "_in:[" + type + "]";
+                }
+            }
+            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] = async ({ options, filter }, req) => {
+                let remult = await api.getRemult(req);
+                let repo = remult.repo(e);
+                let dApi = new DataApi(repo, remult);
+                let result;
+                let err;
+                await dApi.getArray({
+                    success: x => result = x,
+                    created: undefined,
+                    deleted: undefined,
+                    error: x => err = x,
+                    forbidden: () => err = 'forbidden',
+                    notFound: () => err = 'not found',
+                    progress: undefined
+                }, {
+                    get: 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);
+                if (err)
+                    throw err;
+                return result;
+            };
+        }
+    }
+    if (query.length > 0) {
+        query = `type Query {${query}
+}`;
+    }
+    return {
+        rootValue: root,
+        schema: `
+input options{
+    limit:Int
+    page:Int
+    sort:String
+    order:String
+}
+${types}
+${query}
+`
+    };
+}

package/esm/index.d.ts

@@ -0,0 +1,35 @@
+export { Field, Fields, StringFieldOptions, FieldsMetadata, Entity, BuildEntity, 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 { 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 { JsonDataProvider, JsonEntityStorage } from './src/data-providers/json-data-provider';
+export { Controller, BackendMethodOptions, BackendMethod, ProgressListener } from './src/server-action';
+export { Allowed, Allow, Remult, isBackend, AllowedForInstance, EventDispatcher, EventSource, HttpProvider, 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 './valueConverters';
+export { ClassType } from "./classType";
+export { allEntities } from "./src/context";
+export { serializeError } from "./src/data-api";
+export { DataApiRequest } from "./src/data-api";
+export { DataApiResponse } from "./src/data-api";
+export { DataApi } from "./src/data-api";
+export { getEntityKey } from "./src/remult3/index";
+export { jobWasQueuedResult } from "./src/server-action";
+export { queuedJobInfoResponse } from "./src/server-action";
+export { Action, classBackendMethodsArray, serverActionField } from "./src/server-action";
+export { actionInfo } from "./src/server-action";
+export { registerActionsOnServer } from './server/register-actions-on-server';
+export { registerEntitiesOnServer } from './server/register-entities-on-server';

package/esm/index.js

@@ -0,0 +1,29 @@
+/*
+ * Public API Surface of remult
+ */
+export { Field, Fields, Entity, BuildEntity, EntityBase, ControllerBase, FieldType, getFields, getEntityRef, ValueListFieldType, getValueList, ValueListInfo, CaptionTransformer } from './src/remult3';
+export { RestDataProvider } from './src/data-providers/rest-data-provider'; //V
+export { InMemoryDataProvider } from './src/data-providers/in-memory-database'; //V
+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 { 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';
+export { Allow, Remult, isBackend, EventSource } from './src/context';
+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 './valueConverters';
+export { allEntities } from "./src/context";
+export { serializeError } from "./src/data-api";
+export { DataApi } from "./src/data-api";
+export { getEntityKey } from "./src/remult3/index";
+export { Action, classBackendMethodsArray, serverActionField } from "./src/server-action";
+export { actionInfo } from "./src/server-action";
+export { registerActionsOnServer } from './server/register-actions-on-server';
+export { registerEntitiesOnServer } from './server/register-entities-on-server';

package/esm/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/esm/inputTypes.js

@@ -0,0 +1,9 @@
+export class InputTypes {
+}
+InputTypes.number = 'number';
+InputTypes.date = 'date';
+InputTypes.checkbox = 'checkbox';
+InputTypes.password = 'password';
+InputTypes.email = 'email';
+InputTypes.tel = 'tel';
+InputTypes.time = "time";

package/esm/postgres/index.d.ts

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

package/esm/postgres/index.js

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

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

@@ -0,0 +1,40 @@
+import { 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';
+import { FieldMetadata } from '../src/column-interfaces';
+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 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);
+}
+export declare function preparePostgresQueueStorage(sql: SqlDatabase): Promise<import("../server/expressBridge").EntityQueueStorage>;
+export declare function createPostgresConnection(options?: {
+    connectionString?: string;
+    sslInDev?: boolean;
+    configuration?: "heroku" | PoolConfig;
+    autoCreateTables?: boolean;
+}): Promise<SqlDatabase>;

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

@@ -0,0 +1,194 @@
+import { Pool } from 'pg';
+import { allEntities, Remult } from '../src/context';
+import { postgresColumnSyntax } from './postgresColumnSyntax';
+import { getDbNameProvider } from '../src/filter/filter-consumer-bridge-to-sql-request';
+import { isAutoIncrement } from '../src/remult3';
+import { SqlDatabase } from '../src/data-providers/sql-database';
+export class PostgresDataProvider {
+    constructor(pool) {
+        this.pool = pool;
+    }
+    async entityIsUsedForTheFirstTime(entity) {
+    }
+    getLimitSqlSyntax(limit, offset) {
+        return ' limit ' + limit + ' offset ' + offset;
+    }
+    createCommand() {
+        return new PostgresBridgeToSQLCommand(this.pool);
+    }
+    async transaction(action) {
+        let client = await this.pool.connect();
+        try {
+            await client.query('BEGIN');
+            await action({
+                createCommand: () => new PostgresBridgeToSQLCommand(client),
+                entityIsUsedForTheFirstTime: this.entityIsUsedForTheFirstTime,
+                transaction: () => { throw "nested transactions not allowed"; },
+                getLimitSqlSyntax: this.getLimitSqlSyntax
+            });
+            await client.query('COMMIT');
+        }
+        catch (err) {
+            await client.query('ROLLBACK');
+            throw err;
+        }
+        finally {
+            await client.release();
+        }
+    }
+}
+class PostgresBridgeToSQLCommand {
+    constructor(source) {
+        this.source = source;
+        this.values = [];
+    }
+    addParameterAndReturnSqlToken(val) {
+        this.values.push(val);
+        return '$' + this.values.length;
+    }
+    execute(sql) {
+        return this.source.query(sql, this.values).then(r => new PostgresBridgeToSQLQueryResult(r));
+    }
+}
+class PostgresBridgeToSQLQueryResult {
+    constructor(r) {
+        this.r = r;
+        this.rows = r.rows;
+    }
+    getColumnKeyInResultForIndexInSelect(index) {
+        return this.r.fields[index].name;
+    }
+}
+export async function verifyStructureOfAllEntities(db, remult) {
+    return await new PostgresSchemaBuilder(db).verifyStructureOfAllEntities(remult);
+}
+export class PostgresSchemaBuilder {
+    constructor(pool, schema) {
+        this.pool = pool;
+        this.additionalWhere = '';
+        if (schema) {
+            this.additionalWhere = ' and table_schema=\'' + schema + '\'';
+        }
+    }
+    async verifyStructureOfAllEntities(remult) {
+        console.log("start verify structure");
+        for (const entityClass of allEntities) {
+            let entity = remult.repo(entityClass).metadata;
+            let e = await getDbNameProvider(entity);
+            try {
+                if (!entity.options.sqlExpression) {
+                    if ((await e.entityName).toLowerCase().indexOf('from ') < 0) {
+                        await this.createIfNotExist(entity);
+                        await this.verifyAllColumns(entity);
+                    }
+                }
+            }
+            catch (err) {
+                console.log("failed verify structure of " + e.entityName + " ", err);
+            }
+        }
+    }
+    async createIfNotExist(entity) {
+        var c = this.pool.createCommand();
+        let e = await getDbNameProvider(entity);
+        await c.execute("select 1 from information_Schema.tables where table_name=" + c.addParameterAndReturnSqlToken((e.entityName).toLowerCase()) + this.additionalWhere).then(async (r) => {
+            if (r.rows.length == 0) {
+                let result = '';
+                for (const x of entity.fields) {
+                    if (!e.isDbReadonly(x) || isAutoIncrement(x)) {
+                        if (result.length != 0)
+                            result += ',';
+                        result += '\r\n  ';
+                        if (isAutoIncrement(x))
+                            result += e.nameOf(x) + ' serial';
+                        else {
+                            result += postgresColumnSyntax(x, e.nameOf(x));
+                            if (x == entity.idMetadata.field)
+                                result += ' primary key';
+                        }
+                    }
+                }
+                let sql = 'create table ' + e.entityName + ' (' + result + '\r\n)';
+                //console.log(sql);
+                await this.pool.execute(sql);
+            }
+        });
+    }
+    async addColumnIfNotExist(entity, c) {
+        let e = await getDbNameProvider(entity);
+        if (e.isDbReadonly(c(entity)))
+            return;
+        try {
+            let cmd = this.pool.createCommand();
+            const colName = e.nameOf(c(entity));
+            if ((await cmd.execute(`select 1   
+        FROM information_schema.columns 
+        WHERE table_name=${cmd.addParameterAndReturnSqlToken((e.entityName).toLocaleLowerCase())} and column_name=${cmd.addParameterAndReturnSqlToken((colName).toLocaleLowerCase())}` + this.additionalWhere)).rows.length == 0) {
+                let sql = `alter table ${e.entityName} add column ${postgresColumnSyntax(c(entity), colName)}`;
+                //console.log(sql);
+                await this.pool.execute(sql);
+            }
+        }
+        catch (err) {
+            console.log(err);
+        }
+    }
+    async verifyAllColumns(entity) {
+        try {
+            let cmd = this.pool.createCommand();
+            let e = await getDbNameProvider(entity);
+            let cols = (await cmd.execute(`select column_name   
+        FROM information_schema.columns 
+        WHERE table_name=${cmd.addParameterAndReturnSqlToken((e.entityName).toLocaleLowerCase())} ` + this.additionalWhere)).rows.map(x => x.column_name);
+            for (const col of entity.fields) {
+                if (!e.isDbReadonly(col))
+                    if (!cols.includes(e.nameOf(col).toLocaleLowerCase())) {
+                        let sql = `alter table ${e.entityName} add column ${postgresColumnSyntax(col, e.nameOf(col))}`;
+                        //console.log(sql);
+                        await this.pool.execute(sql);
+                    }
+            }
+        }
+        catch (err) {
+            console.log(err);
+        }
+    }
+}
+export async function preparePostgresQueueStorage(sql) {
+    let c = new Remult();
+    c.setDataProvider(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);
+    return new (await import('../server/expressBridge')).EntityQueueStorage(c.repo(JobsInQueueEntity));
+}
+export async function createPostgresConnection(options) {
+    if (!options)
+        options = {};
+    let 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;
+    }
+    const db = new SqlDatabase(new PostgresDataProvider(new Pool(config)));
+    let remult = new Remult();
+    remult.setDataProvider(db);
+    if (options.autoCreateTables === undefined || options.autoCreateTables)
+        await verifyStructureOfAllEntities(db, remult);
+    return db;
+}

package/esm/postgres/postgresColumnSyntax.d.ts

@@ -0,0 +1,2 @@
+import { FieldMetadata } from '../src/column-interfaces';
+export declare function postgresColumnSyntax(x: FieldMetadata, dbName: string): string;