remult 0.22.2 → 0.22.3

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);
-}

package/esm/core/postgres/schema-builder.js

@@ -1,153 +0,0 @@
-import { allEntities } from '../src/context';
-import { dbNamesOf, isDbReadonly } from '../src/filter/filter-consumer-bridge-to-sql-request';
-import { remult as defaultRemult } from '../src/remult-proxy';
-import { isAutoIncrement } from '../src/remult3';
-import { ValueConverters } from '../src/valueConverters';
-export function postgresColumnSyntax(x, dbName) {
-    let result = dbName;
-    if (x.valueType == Number) {
-        if (!x.valueConverter.fieldTypeInDb)
-            result += " numeric" + (x.allowNull ? "" : " default 0 not null");
-        else
-            result += " " + x.valueConverter.fieldTypeInDb + (x.allowNull ? "" : " default 0 not null");
-    }
-    else if (x.valueType == Date) {
-        if (!x.valueConverter.fieldTypeInDb)
-            if (x.valueConverter == ValueConverters.DateOnly)
-                result += " date";
-            else
-                result += " timestamp";
-        else
-            result += " " + x.valueConverter.fieldTypeInDb;
-    }
-    else if (x.valueType == Boolean)
-        result += " boolean" + (x.allowNull ? "" : " default false not null");
-    else if (x.valueConverter.fieldTypeInDb) {
-        result += " " + x.valueConverter.fieldTypeInDb;
-        if (!x.allowNull && x.valueConverter.fieldTypeInDb == 'integer') {
-            result += " default 0 not null";
-        }
-    }
-    else
-        result += " varchar" + (x.allowNull ? "" : " default '' not null");
-    return result;
-}
-export async function verifyStructureOfAllEntities(db, remult) {
-    return await new PostgresSchemaBuilder(db).verifyStructureOfAllEntities(remult);
-}
-export class PostgresSchemaBuilder {
-    pool;
-    //@internal
-    static logToConsole = true;
-    async verifyStructureOfAllEntities(remult) {
-        if (!remult) {
-            remult = defaultRemult;
-        }
-        const completed = new Set();
-        const entities = [];
-        for (const entityClass of [...allEntities].reverse()) {
-            let entity = remult.repo(entityClass).metadata;
-            let e = await dbNamesOf(entity);
-            if (completed.has(e.$entityName))
-                continue;
-            completed.add(e.$entityName);
-            entities.push(entity);
-        }
-        await this.ensureSchema(entities);
-    }
-    async ensureSchema(entities) {
-        for (const entity of entities) {
-            let e = await dbNamesOf(entity);
-            try {
-                if (!entity.options.sqlExpression) {
-                    if (e.$entityName.toLowerCase().indexOf('from ') < 0) {
-                        await this.createIfNotExist(entity);
-                        await this.verifyAllColumns(entity);
-                    }
-                }
-            }
-            catch (err) {
-                console.error("failed verify structure of " + e.$entityName + " ", err);
-            }
-        }
-    }
-    async createIfNotExist(entity) {
-        var c = this.pool.createCommand();
-        let e = await dbNamesOf(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 (!isDbReadonly(x, e) || isAutoIncrement(x)) {
-                        if (result.length != 0)
-                            result += ',';
-                        result += '\r\n  ';
-                        if (isAutoIncrement(x))
-                            result += e.$dbNameOf(x) + ' serial';
-                        else {
-                            result += postgresColumnSyntax(x, e.$dbNameOf(x));
-                        }
-                        if (x == entity.idMetadata.field)
-                            result += ' primary key';
-                    }
-                }
-                let sql = 'create table ' + e.$entityName + ' (' + result + '\r\n)';
-                if (PostgresSchemaBuilder.logToConsole)
-                    console.info(sql);
-                await this.pool.execute(sql);
-            }
-        });
-    }
-    async addColumnIfNotExist(entity, c) {
-        let e = await dbNamesOf(entity);
-        if (isDbReadonly(c(entity), e))
-            return;
-        try {
-            let cmd = this.pool.createCommand();
-            const colName = e.$dbNameOf(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)}`;
-                if (PostgresSchemaBuilder.logToConsole)
-                    console.info(sql);
-                await this.pool.execute(sql);
-            }
-        }
-        catch (err) {
-            console.error(err);
-        }
-    }
-    async verifyAllColumns(entity) {
-        try {
-            let cmd = this.pool.createCommand();
-            let e = await dbNamesOf(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.toLocaleLowerCase());
-            for (const col of entity.fields) {
-                if (!isDbReadonly(col, e)) {
-                    let colName = e.$dbNameOf(col).toLocaleLowerCase();
-                    if (colName.startsWith('"') && colName.endsWith('"'))
-                        colName = colName.substring(1, colName.length - 1);
-                    if (!cols.includes(colName)) {
-                        let sql = `alter table ${e.$entityName} add column ${postgresColumnSyntax(col, e.$dbNameOf(col))}`;
-                        if (PostgresSchemaBuilder.logToConsole)
-                            console.info(sql);
-                        await this.pool.execute(sql);
-                    }
-                }
-            }
-        }
-        catch (err) {
-            console.error(err);
-        }
-    }
-    additionalWhere = '';
-    constructor(pool, schema) {
-        this.pool = pool;
-        if (schema) {
-            this.additionalWhere = ' and table_schema=\'' + schema + '\'';
-        }
-    }
-}

package/esm/core/remult-fresh.d.ts

@@ -1,17 +0,0 @@
-import { RemultServerOptions, RemultServerCore } from "./server/expressBridge";
-export declare function remultFresh(options: RemultServerOptions<FreshRequest>, response: FreshResponse): RemultFresh;
-export interface RemultFresh extends RemultServerCore<FreshRequest> {
-    handle(req: FreshRequest, ctx: FreshContext): Promise<any>;
-}
-export interface FreshRequest {
-    url: string;
-    method: string;
-    json: () => Promise<any>;
-}
-export interface FreshContext {
-    next: () => Promise<any>;
-}
-export interface FreshResponse {
-    new (body?: any | undefined, init?: ResponseInit): any;
-    json(data: unknown, init?: ResponseInit): any;
-}