remult 0.22.3 → 0.22.4

package/esm/angular/src/angular/data-control/data-control2.component.js

@@ -0,0 +1,138 @@
+import { Component, Input, ViewChild, ViewContainerRef } from '@angular/core';
+import { ErrorStateMatcher } from '@angular/material/core';
+import { decorateDataSettings, FieldCollection } from '../../../interfaces';
+@Component({
+    selector: 'data-control',
+    templateUrl: './data-control2.component.html',
+    styleUrls: ['./data-control2.component.scss']
+})
+export class DataControl2Component {
+    plugin;
+    componentFactoryResolver;
+    @Input()
+    map;
+    @Input()
+    set field(value) {
+        this.map = {
+            field: value
+        };
+        decorateDataSettings(this.map.field, this.map);
+        this.settings.augment(this.plugin.dataControlAugmenter, this.map);
+        this.initCustomComponent();
+    }
+    constructor(plugin, componentFactoryResolver) {
+        this.plugin = plugin;
+        this.componentFactoryResolver = componentFactoryResolver;
+    }
+    @ViewChild('theId', { read: ViewContainerRef, static: true })
+    theId;
+    done = false;
+    initCustomComponent() {
+        if (this.map?.customComponent?.component) {
+            if (this.done)
+                return;
+            const fieldRef = this.map.field;
+            if (!fieldRef.metadata) {
+                this.map.customComponent = undefined;
+                return;
+            }
+            this.done = true;
+            const componentFactory = this.componentFactoryResolver.resolveComponentFactory(this.map.customComponent.component);
+            const viewContainerRef = this.theId;
+            viewContainerRef.clear();
+            const componentRef = viewContainerRef.createComponent(componentFactory);
+            componentRef.instance.args = {
+                fieldRef,
+                settings: this.map
+            };
+        }
+    }
+    @Input()
+    record;
+    @Input()
+    notReadonly = false;
+    @Input()
+    settings = new FieldCollection(undefined, () => true, undefined, undefined, () => undefined);
+    showDescription() {
+        return (this.map.field) && this.map.getValue || !this._getEditable();
+    }
+    getDropDown() {
+        return this.map.valueList;
+    }
+    showClick() {
+        if (!this.map.click)
+            return false;
+        if (!this._getEditable())
+            return false;
+        if (this.map.allowClick === undefined) {
+            return true;
+        }
+        return this.settings.allowClick(this.map, this.record);
+    }
+    click() {
+        if (this.showClick())
+            this.settings._click(this.map, this.record);
+    }
+    getClickIcon() {
+        if (this.map.clickIcon)
+            return this.map.clickIcon;
+        return 'keyboard_arrow_down';
+    }
+    dataControlStyle() {
+        return this.settings.__dataControlStyle(this.map);
+    }
+    dummy = { inputValue: '' };
+    _getColumn() {
+        if (!this.map.field)
+            return this.dummy;
+        return this.settings.__getColumn(this.map, this.record);
+    }
+    _getEditable() {
+        if (this.notReadonly)
+            return true;
+        return this.settings._getEditable(this.map, this.record);
+    }
+    ngOnChanges() {
+        this.initCustomComponent();
+    }
+    isSelect() {
+        if (this.map.valueList && this._getEditable())
+            return true;
+        return false;
+    }
+    showTextBox() {
+        return !this.isSelect() && !this.showCheckbox();
+    }
+    showCheckbox() {
+        return this.settings._getColDataType(this.map) == 'checkbox';
+    }
+    getError() {
+        return this.settings._getError(this.map, this.record);
+    }
+    getStyle() {
+        if (this.showDescription()) {
+            if (this.map.hideDataOnInput || !this._getEditable()) {
+                return { display: 'none' };
+            }
+            return { width: '50px' };
+        }
+        return {};
+    }
+    getFloatLabel() {
+        if (this.showDescription()) {
+            if (this.settings._getColDisplayValue(this.map, this.record))
+                return 'always';
+        }
+        return 'auto';
+    }
+    ngErrorStateMatches = new class extends ErrorStateMatcher {
+        parent;
+        constructor(parent) {
+            super();
+            this.parent = parent;
+        }
+        isErrorState() {
+            return !!this.parent.getError();
+        }
+    }(this);
+}

package/esm/core/SseSubscriptionServer.d.ts

@@ -0,0 +1,33 @@
+/// <reference types="node" />
+import { GenericRequestInfo, GenericResponse } from './server/index';
+import { Remult } from './src/context';
+import { ServerEventChannelSubscribeDTO } from './src/live-query/SubscriptionChannel';
+import { SubscriptionServer } from './src/live-query/SubscriptionServer';
+import { DataApiResponse } from './src/data-api';
+export declare class SseSubscriptionServer implements SubscriptionServer {
+    private canUserConnectToChannel?;
+    subscribeToChannel({ channel, clientId }: ServerEventChannelSubscribeDTO, res: DataApiResponse, remult: Remult, remove?: boolean): void;
+    private connections;
+    constructor(canUserConnectToChannel?: ((channel: string, remult: Remult) => boolean) | undefined);
+    publishMessage<T>(channel: string, message: any): Promise<void>;
+    debugMessageFileSaver: (id: any, channel: any, message: any) => void;
+    openHttpServerStream(req: GenericRequestInfo, res: GenericResponse & ResponseRequiredForSSE): clientConnection;
+    debug(): void;
+    debugFileSaver: (x: any) => 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>;
+    timeOutRef: NodeJS.Timeout;
+    close(): void;
+    closed: boolean;
+    write(eventData: string, eventType?: string): void;
+    connectionId: any;
+    constructor(response: GenericResponse & ResponseRequiredForSSE);
+    sendLiveMessage(): void;
+}

package/esm/core/SseSubscriptionServer.js

@@ -0,0 +1,107 @@
+import { v4 as uuid } from 'uuid';
+import { ConnectionNotFoundError } from './src/live-query/SseSubscriptionClient';
+export class SseSubscriptionServer {
+    canUserConnectToChannel;
+    //@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({ status: "ok" });
+                    this.debug();
+                    return;
+                }
+                else {
+                    res.forbidden();
+                    this.debug();
+                    return;
+                }
+            }
+        }
+        res.success(ConnectionNotFoundError);
+    }
+    //@internal
+    connections = [];
+    constructor(canUserConnectToChannel) {
+        this.canUserConnectToChannel = canUserConnectToChannel;
+        if (!this.canUserConnectToChannel) {
+            this.canUserConnectToChannel = () => true;
+        }
+    }
+    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
+    debugMessageFileSaver = (id, channel, message) => { };
+    //@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
+        })));
+    }
+    //@internal
+    debugFileSaver = () => { };
+}
+export class clientConnection {
+    response;
+    channels = {};
+    timeOutRef;
+    close() {
+        if (this.timeOutRef)
+            clearTimeout(this.timeOutRef);
+        this.closed = true;
+    }
+    closed = false;
+    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();
+    }
+    connectionId = uuid();
+    constructor(response) {
+        this.response = response;
+        this.write(this.connectionId, "connectionId");
+        this.sendLiveMessage();
+    }
+    sendLiveMessage() {
+        if (this.closed)
+            return;
+        this.write("", "keep-alive");
+        this.timeOutRef = setTimeout(() => {
+            this.sendLiveMessage();
+        }, 45000);
+    }
+}

package/esm/core/assign.d.ts

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

package/esm/core/assign.js

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

package/esm/core/classType.d.ts

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

package/esm/core/classType.js

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

package/esm/core/index.d.ts

@@ -0,0 +1,27 @@
+export { Field, Fields, FieldsMetadata, Entity, IdEntity, 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';
+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, 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, UserInfo } from './src/context';
+export { ExternalHttpProvider } from './src/buildRestDataProvider';
+export { SortSegment, Sort } from './src/sort';
+export { OneToMany, CompoundIdField } from './src/column';
+export { Filter } from './src/filter/filter-interfaces';
+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/core/index.js

@@ -0,0 +1,25 @@
+/*
+ * Public API Surface of remult
+ */
+export { Field, Fields, Entity, IdEntity, EntityBase, ControllerBase, FieldType, getFields, getEntityRef, ValueListFieldType, getValueList, ValueListInfo, CaptionTransformer } from './src/remult3';
+export { describeClass } from './src/remult3/DecoratorReplacer';
+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 { 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';
+export { Allow, Remult, isBackend, EventSource } from './src/context';
+export { Sort } from './src/sort';
+export { OneToMany, CompoundIdField } from './src/column';
+export { Filter } from './src/filter/filter-interfaces';
+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/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/esm/core/inputTypes.js

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

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

@@ -0,0 +1,22 @@
+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[]>;
+}
+export declare class LiveQueryStorageEntity extends EntityBase {
+    id: string;
+    entityKey: string;
+    data: any;
+    lastUsedIso: string;
+}

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

@@ -0,0 +1,71 @@
+import { initDataProvider } from "../server/initDataProvider";
+import { allEntities, Remult } from "../src/context";
+import { Entity, EntityBase, Fields } from "../src/remult3";
+export class DataProviderLiveQueryStorage {
+    repo;
+    dataProvider;
+    constructor(dataProvider) {
+        this.dataProvider = initDataProvider(dataProvider);
+        this.repo = this.dataProvider.then(dp => new Remult(dp).repo(LiveQueryStorageEntity));
+    }
+    async ensureSchema() {
+        const dp = await this.dataProvider;
+        if (dp.ensureSchema)
+            await dp.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(async (repo) => {
+            const r = await repo.findId(queryId);
+            if (r)
+                await repo.delete(r);
+        }).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;
+    }
+}
+@Entity(undefined, {
+    dbName: 'remult_live_query_storage'
+})
+/*@internal */
+export class LiveQueryStorageEntity extends EntityBase {
+    @Fields.string()
+    id = '';
+    @Fields.string()
+    entityKey = '';
+    @Fields.object()
+    data;
+    @Fields.string()
+    lastUsedIso = new Date().toISOString();
+}
+allEntities.splice(allEntities.indexOf(LiveQueryStorageEntity), 1);

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

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

package/esm/core/postgres/index.js

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

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

@@ -0,0 +1,36 @@
+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';
+export interface PostgresPool extends PostgresCommandSource {
+    connect(): Promise<PostgresClient>;
+}
+export interface PostgresClient extends PostgresCommandSource {
+    release(): void;
+}
+export declare class PostgresDataProvider implements SqlImplementation {
+    private pool;
+    supportsJsonColumnType: boolean;
+    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 {
+    query(queryText: string, values?: any[]): Promise<QueryResult>;
+}
+export declare function createPostgresConnection(options?: {
+    connectionString?: string;
+    sslInDev?: boolean;
+    configuration?: "heroku" | PoolConfig;
+}): Promise<SqlDatabase>;
+export declare function createPostgresDataProvider(options?: {
+    connectionString?: string;
+    sslInDev?: boolean;
+    configuration?: "heroku" | PoolConfig;
+}): Promise<SqlDatabase>;
+export declare function preparePostgresQueueStorage(sql: SqlDatabase): Promise<import("../server/expressBridge").EntityQueueStorage>;

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

@@ -0,0 +1,120 @@
+import { Pool } from 'pg';
+import { Remult } from '../src/context';
+import { PostgresSchemaBuilder } from './schema-builder';
+import { SqlDatabase } from '../src/data-providers/sql-database';
+export class PostgresDataProvider {
+    pool;
+    supportsJsonColumnType = true;
+    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) {
+        return ' limit ' + limit + ' offset ' + offset;
+    }
+    createCommand() {
+        return new PostgresBridgeToSQLCommand(this.pool);
+    }
+    constructor(pool) {
+        this.pool = 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 {
+            await client.query('BEGIN');
+            await action({
+                createCommand: () => new PostgresBridgeToSQLCommand(client),
+                entityIsUsedForTheFirstTime: this.entityIsUsedForTheFirstTime,
+                transaction: () => { throw "nested transactions not allowed"; },
+                getLimitSqlSyntax: this.getLimitSqlSyntax,
+                supportsJsonColumnType: this.supportsJsonColumnType,
+                //@ts-ignore
+                pool: client
+            });
+            await client.query('COMMIT');
+        }
+        catch (err) {
+            await client.query('ROLLBACK');
+            throw err;
+        }
+        finally {
+            await client.release();
+        }
+    }
+}
+class PostgresBridgeToSQLCommand {
+    source;
+    constructor(source) {
+        this.source = source;
+    }
+    values = [];
+    addParameterAndReturnSqlToken(val) {
+        if (Array.isArray(val))
+            val = JSON.stringify(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 {
+    r;
+    getColumnKeyInResultForIndexInSelect(index) {
+        return this.r.fields[index].name;
+    }
+    constructor(r) {
+        this.r = r;
+        this.rows = r.rows;
+    }
+    rows;
+}
+export async function createPostgresConnection(options) {
+    return createPostgresDataProvider(options);
+}
+export async function createPostgresDataProvider(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.dataProvider = (db);
+    return db;
+}
+export async function preparePostgresQueueStorage(sql) {
+    let c = new Remult();
+    c.dataProvider = (sql);
+    let JobsInQueueEntity = (await import('../server/expressBridge')).JobsInQueueEntity;
+    let e = c.repo(JobsInQueueEntity);
+    await sql.ensureSchema([e.metadata]);
+    return new (await import('../server/expressBridge')).EntityQueueStorage(c.repo(JobsInQueueEntity));
+}

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

@@ -0,0 +1,17 @@
+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;
+    static logToConsole: boolean;
+    verifyStructureOfAllEntities(remult?: Remult): Promise<void>;
+    ensureSchema(entities: EntityMetadata<any>[]): 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);
+}