remult 0.22.1 → 0.22.3

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

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

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

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

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

package/esm/core/assign.js

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

package/esm/core/classType.d.ts

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

package/esm/core/classType.js

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

package/esm/core/index.d.ts

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

@@ -1,25 +0,0 @@
-/*
- * 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

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

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

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

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

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

package/esm/core/postgres/index.js

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

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

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

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

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