remult 0.18.1-exp.2 → 0.18.1-exp.21

package/esm/src/shared-tests/db-tests.db-tests.js

@@ -13,11 +13,12 @@ import { Remult } from "../context";
 import { dWithPrefilter } from "../tests/dWithPrefilter";
 import { entityFilterToJson, Filter } from "../filter/filter-interfaces";
 import { d } from "../tests/d";
-import { entityForCustomFilter1 } from "../tests/entityForCustomFilter";
+import { entityForrawFilter1 } from "../tests/entityForCustomFilter";
 import { entityWithValidationsOnColumn } from "../tests/entityWithValidationsOnColumn";
 import { Validators } from "../validators";
 import { Status } from "../tests/testModel/models";
 import { IdEntity } from "../id-entity";
+import { describeClass } from "../remult3/DecoratorReplacer";
 testAll("what", async ({ remult, createEntity }) => {
     await (await createEntity(stam)).create({ id: 1, title: 'noam' }).save();
     expect(await remult.repo(stam).count()).toBe(1);
@@ -124,13 +125,37 @@ testAll("put with validations on entity fails", async ({ remult, createEntity })
     x = await s.find({ where: { myId: 1 } });
     expect(x[0].name).toBe('noam');
 });
-testAll("test date with null works", async ({ createEntity }) => {
+testAll("test date only with null works", async ({ createEntity }) => {
     let repo = await createEntity(testDateWithNull);
     let r = repo.create({ id: 0 });
     await r.save();
     r = await repo.findFirst();
     expect(r.d).toBeNull();
     expect(await repo.count({ d: null })).toBe(1);
+    r.d = new Date(1976, 5, 16);
+    await r.save();
+    expect(r.d.getFullYear()).toBe(1976);
+    r = await repo.findFirst();
+    expect(r.d.getFullYear()).toBe(1976);
+    r.d = null;
+    await r.save();
+    expect(r.d).toBeNull();
+}, false);
+testAll("test date with null works", async ({ createEntity }) => {
+    let repo = await createEntity(testDateWithNull);
+    let r = repo.create({ id: 0 });
+    await r.save();
+    r = await repo.findFirst();
+    expect(r.fullDate).toBeNull("expected null after");
+    expect(await repo.count({ fullDate: null })).toBe(1);
+    r.fullDate = new Date(1976, 5, 16);
+    await r.save();
+    expect(r.fullDate.getFullYear()).toBe(1976);
+    r = await repo.findFirst();
+    expect(r.fullDate.getFullYear()).toBe(1976);
+    r.fullDate = null;
+    await r.save();
+    expect(r.fullDate).toBeNull();
 }, false);
 testAll("test original value of date", async ({ createEntity }) => {
     let r = await (await createEntity(testDateWithNull)).create({ id: 1, d: new Date(1976, 6, 16) }).save();
@@ -140,6 +165,7 @@ let testDateWithNull = class testDateWithNull extends EntityBase {
     constructor() {
         super(...arguments);
         this.id = 0;
+        this.fullDate = null;
     }
 };
 __decorate([
@@ -150,6 +176,10 @@ __decorate([
     Fields.dateOnly({ allowNull: true }),
     __metadata("design:type", Date)
 ], testDateWithNull.prototype, "d", void 0);
+__decorate([
+    Fields.date({ allowNull: true }),
+    __metadata("design:type", Date)
+], testDateWithNull.prototype, "fullDate", void 0);
 testDateWithNull = __decorate([
     Entity('testDateWithNull', { allowApiCrud: true })
 ], testDateWithNull);
@@ -204,7 +234,7 @@ testAll("test paging with complex object", async ({ remult, createEntity }) => {
         i++;
     }
     expect(i).toBe(5);
-});
+}, false);
 testAll("test paging with complex object_2", async ({ remult, createEntity }) => {
     let c1 = await (await createEntity(c)).create({ id: 1, name: 'c1' }).save();
     await (await createEntity(p)).create({ id: 1, name: 'p1', c: c1 }).save();
@@ -237,13 +267,13 @@ testAll("test filter doesn't collapse", async ({ createEntity }) => {
     expect((await repo.find({ where: f })).length).toBe(2);
 });
 testAll("test that it works with inheritance", async ({ createEntity }) => {
-    let c = await createEntity(entityForCustomFilter1);
+    let c = await createEntity(entityForrawFilter1);
     for (let id = 0; id < 5; id++) {
         await c.create({ id }).save();
     }
-    expect(await (c.count(entityForCustomFilter1.oneAndThree()))).toBe(2);
-    expect((await (c.findFirst(entityForCustomFilter1.testNumericValue(2)))).id).toBe(2);
-    expect((await (c.findFirst(entityForCustomFilter1.testObjectValue({ val: 2 })))).id).toBe(2);
+    expect(await (c.count(entityForrawFilter1.oneAndThree()))).toBe(2);
+    expect((await (c.findFirst(entityForrawFilter1.testNumericValue(2)))).id).toBe(2);
+    expect((await (c.findFirst(entityForrawFilter1.testObjectValue({ val: 2 })))).id).toBe(2);
 });
 testAll("put with validations on column fails", async ({ remult, createEntity }) => {
     var s = await createEntity(entityWithValidationsOnColumn);
@@ -412,7 +442,7 @@ testAllDbs("get array works with filter in body", async ({ createData, remult })
             return undefined;
         }
     }, {
-        status_in: '[1, 2]'
+        "status.in": '[1, 2]'
     });
     d.test();
 }, false);
@@ -537,7 +567,7 @@ let testFilter = class testFilter {
         this.c = '';
     }
 };
-testFilter.search = Filter.createCustom((remult, str) => ({
+testFilter.search = Filter.createCustom((str, remult) => ({
     $and: [{
             $or: [
                 { a: 'a' },
@@ -721,3 +751,19 @@ testAll("test transaction rollback", async ({ db }) => {
     }
     expect(fail).toBe(true);
 });
+testAll("test date", async ({ createEntity }) => {
+    const e = class {
+        constructor() {
+            this.a = 0;
+            this.d = new Date();
+        }
+    };
+    describeClass(e, Entity("tdate", { allowApiCrud: true }), {
+        a: Fields.number(),
+        d: Fields.date()
+    });
+    const r = await createEntity(e);
+    await r.insert({ a: 1, d: new Date(1976, 5, 16) });
+    let item = await r.findFirst();
+    expect(item.d.getFullYear()).toBe(1976);
+}, false);

package/esm/src/sql-command.d.ts

@@ -5,10 +5,12 @@ export interface SqlImplementation {
     transaction(action: (sql: SqlImplementation) => Promise<void>): Promise<void>;
     entityIsUsedForTheFirstTime(entity: EntityMetadata): Promise<void>;
 }
-export interface SqlCommand {
-    addParameterAndReturnSqlToken(val: any): string;
+export interface SqlCommand extends SqlCommandWithParameters {
     execute(sql: string): Promise<SqlResult>;
 }
+export interface SqlCommandWithParameters {
+    addParameterAndReturnSqlToken(val: any): string;
+}
 export interface SqlResult {
     rows: any[];
     getColumnKeyInResultForIndexInSelect(index: number): string;

package/esm/src/tests/entityForCustomFilter.d.ts

@@ -1,16 +1,16 @@
 import { EntityBase, EntityFilter } from '../remult3';
-export declare class entityForCustomFilter extends EntityBase {
+export declare class entityForrawFilter extends EntityBase {
     id: number;
     static filter: ((y: {
         oneAndThree?: boolean;
         dbOneOrThree?: boolean;
         two?: boolean;
-    }) => EntityFilter<entityForCustomFilter>) & import("../filter/filter-interfaces").customFilterInfo<entityForCustomFilter>;
-    static oneAndThree: (() => EntityFilter<entityForCustomFilter>) & import("../filter/filter-interfaces").customFilterInfo<entityForCustomFilter>;
-    static testNumericValue: ((y: number) => EntityFilter<entityForCustomFilter>) & import("../filter/filter-interfaces").customFilterInfo<entityForCustomFilter>;
+    }) => EntityFilter<entityForrawFilter>) & import("../filter/filter-interfaces").rawFilterInfo<entityForrawFilter>;
+    static oneAndThree: (() => EntityFilter<entityForrawFilter>) & import("../filter/filter-interfaces").rawFilterInfo<entityForrawFilter>;
+    static testNumericValue: ((y: number) => EntityFilter<entityForrawFilter>) & import("../filter/filter-interfaces").rawFilterInfo<entityForrawFilter>;
     static testObjectValue: ((y: {
         val: number;
-    }) => EntityFilter<entityForCustomFilter>) & import("../filter/filter-interfaces").customFilterInfo<entityForCustomFilter>;
+    }) => EntityFilter<entityForrawFilter>) & import("../filter/filter-interfaces").rawFilterInfo<entityForrawFilter>;
 }
-export declare class entityForCustomFilter1 extends entityForCustomFilter {
+export declare class entityForrawFilter1 extends entityForrawFilter {
 }

package/esm/src/tests/entityForCustomFilter.js

@@ -1,44 +1,43 @@
-var entityForCustomFilter_1;
+var entityForrawFilter_1;
 import { __decorate, __metadata } from "tslib";
 import { SqlDatabase } from '../data-providers/sql-database';
 import { Entity, EntityBase, Fields } from '../remult3';
 import { Filter } from '../filter/filter-interfaces';
 import { ArrayEntityDataProvider } from '../data-providers/array-entity-data-provider';
-import { getDbNameProvider } from '../filter/filter-consumer-bridge-to-sql-request';
-let entityForCustomFilter = entityForCustomFilter_1 = class entityForCustomFilter extends EntityBase {
+import { dbNamesOf } from '../filter/filter-consumer-bridge-to-sql-request';
+let entityForrawFilter = entityForrawFilter_1 = class entityForrawFilter extends EntityBase {
 };
-entityForCustomFilter.filter = Filter.createCustom(async (remult, c) => {
+entityForrawFilter.filter = Filter.createCustom(async (c, remult) => {
     let r = [];
     if (c.oneAndThree)
         r.push({ id: [1, 3] });
     if (c.two)
         r.push({ id: 2 });
     if (c.dbOneOrThree) {
-        let meta = remult.repo(entityForCustomFilter_1).metadata;
-        const e = await getDbNameProvider(meta);
+        const e = await dbNamesOf(remult.repo(entityForrawFilter_1));
         r.push({
             $and: [
-                SqlDatabase.customFilter(async (x) => x.sql = e.nameOf(meta.fields.id) + ' in (' + x.addParameterAndReturnSqlToken(1) + "," + x.addParameterAndReturnSqlToken(3) + ")"),
-                ArrayEntityDataProvider.customFilter(x => x.id == 1 || x.id == 3)
+                SqlDatabase.rawFilter(async (x) => x.sql = e.id + ' in (' + x.addParameterAndReturnSqlToken(1) + "," + x.addParameterAndReturnSqlToken(3) + ")"),
+                ArrayEntityDataProvider.rawFilter(x => x.id == 1 || x.id == 3)
             ]
         });
     }
     return { $and: r };
 });
-entityForCustomFilter.oneAndThree = Filter.createCustom(() => ({ id: [1, 3] }));
-entityForCustomFilter.testNumericValue = Filter.createCustom((r, val) => ({ id: val }));
-entityForCustomFilter.testObjectValue = Filter.createCustom((r, val) => ({ id: val.val }));
+entityForrawFilter.oneAndThree = Filter.createCustom(() => ({ id: [1, 3] }));
+entityForrawFilter.testNumericValue = Filter.createCustom((val) => ({ id: val }));
+entityForrawFilter.testObjectValue = Filter.createCustom((val) => ({ id: val.val }));
 __decorate([
     Fields.integer(),
     __metadata("design:type", Number)
-], entityForCustomFilter.prototype, "id", void 0);
-entityForCustomFilter = entityForCustomFilter_1 = __decorate([
-    Entity('entityForCustomFilter', { allowApiCrud: true })
-], entityForCustomFilter);
-export { entityForCustomFilter };
-let entityForCustomFilter1 = class entityForCustomFilter1 extends entityForCustomFilter {
+], entityForrawFilter.prototype, "id", void 0);
+entityForrawFilter = entityForrawFilter_1 = __decorate([
+    Entity('entityForrawFilter', { allowApiCrud: true })
+], entityForrawFilter);
+export { entityForrawFilter };
+let entityForrawFilter1 = class entityForrawFilter1 extends entityForrawFilter {
 };
-entityForCustomFilter1 = __decorate([
-    Entity('entityForCustomFilter1', { allowApiCrud: true })
-], entityForCustomFilter1);
-export { entityForCustomFilter1 };
+entityForrawFilter1 = __decorate([
+    Entity('entityForrawFilter1', { allowApiCrud: true })
+], entityForrawFilter1);
+export { entityForrawFilter1 };

package/esm/src/tests/frontend-database-tests-setup.spec.js

@@ -1,5 +1,5 @@
 import { addDatabaseToTest, itWithFocus } from "../shared-tests/db-tests-setup";
-import { InMemoryDataProvider } from "../..";
+import { InMemoryDataProvider, remult } from "../..";
 import { Remult } from "../context";
 import { SqlDatabase } from "../data-providers/sql-database";
 import { WebSqlDataProvider } from "../data-providers/web-sql-data-provider";
@@ -28,7 +28,6 @@ export function testRest(key, what, focus = false) {
     itWithFocus(key + " - Rest Provider", async () => {
         let r = new Remult();
         r.dataProvider = (new InMemoryDataProvider());
-        let remult = new Remult();
         let db = new MockRestDataProvider(r);
         remult.dataProvider = (db);
         await what({ db, remult, createEntity: async (x) => remult.repo(x) });

package/esm/src/tests/testHelper.spec.d.ts

@@ -31,6 +31,6 @@ export declare class MockRestDataProvider implements DataProvider {
     constructor(remult: Remult);
     getEntityDataProvider(metadata: EntityMetadata<any>): EntityDataProvider;
     transaction(action: (dataProvider: DataProvider) => Promise<void>): Promise<void>;
-    supportsCustomFilter: boolean;
+    supportsrawFilter: boolean;
 }
-export declare function createMockHttpDataProvider(dataApi: DataApi<any>): import("c:/Repos/radweb/projects/core/src/data-interfaces").RestDataProviderHttpProvider;
+export declare function createMockHttpDataProvider(dataApi: DataApi<any>): import("../data-interfaces").RestDataProviderHttpProvider;

package/esm/src/tests/testHelper.spec.js

@@ -104,7 +104,6 @@ export async function testSql(runAsync) {
     await runAsync({ db: sql, remult });
 }
 export async function testInMemoryDb(runAsync) {
-    let remult = new Remult();
     let db = new InMemoryDataProvider();
     remult.dataProvider = (db);
     await runAsync({ db, remult });
@@ -155,7 +154,7 @@ function urlToReq(url) {
 export class MockRestDataProvider {
     constructor(remult) {
         this.remult = remult;
-        this.supportsCustomFilter = true;
+        this.supportsrawFilter = true;
     }
     getEntityDataProvider(metadata) {
         let dataApi = new DataApi(this.remult.repo(metadata.entityType), this.remult);

package/esm/src/valueConverters.js

@@ -3,6 +3,8 @@ export class ValueConverters {
 }
 ValueConverters.Date = {
     toJson: (val) => {
+        if (val === null)
+            return null;
         if (!val)
             return '';
         if (typeof (val) === "string")
@@ -11,11 +13,12 @@ ValueConverters.Date = {
             return val.toISOString();
         }
         else {
-            console.error("ToJsonError", val);
-            throw new Error("Expected date but got val");
+            throw new Error("Expected date but got " + val);
         }
     },
     fromJson: (val) => {
+        if (val === null)
+            return null;
         if (val == undefined)
             return undefined;
         if (val == '')
@@ -25,7 +28,15 @@ ValueConverters.Date = {
         return new Date(Date.parse(val));
     },
     toDb: x => x,
-    fromDb: x => x,
+    fromDb: val => {
+        if (typeof val === "number")
+            val = new Date(val);
+        if (typeof (val) === "string")
+            val = new Date(val);
+        if (val && !(val instanceof Date))
+            throw "expected date but got " + val;
+        return val;
+    },
     fromInput: x => ValueConverters.Date.fromJson(x),
     toInput: x => ValueConverters.Date.toJson(x),
     displayValue: (val) => {
@@ -63,10 +74,7 @@ ValueConverters.DateOnly = {
     } //when using date storage,  the database expects and returns a date local and every where else we reflect on date iso
     ,
     fromDb: (val) => {
-        var d = val;
-        if (!d)
-            return null;
-        return val;
+        return ValueConverters.Date.fromDb(val);
     },
     fieldTypeInDb: 'date',
     displayValue: (value) => {
@@ -100,6 +108,8 @@ ValueConverters.Boolean = {
     fromJson: value => {
         if (typeof value === "boolean")
             return value;
+        if (value === 1)
+            return true;
         if (value !== undefined && value !== null) {
             return value.toString().trim().toLowerCase() == 'true';
         }

package/index.d.ts

@@ -1,4 +1,4 @@
-export { Field, Fields, FieldsMetadata, Entity, EntityBase, ControllerBase, FieldRef, IdFieldRef, FieldsRef, EntityMetadata, EntityOrderBy, EntityFilter, FindOptions, QueryResult, QueryOptions, Repository, FieldType, FindFirstOptions, ComparisonValueFilter, ValueFilter, IdFilter, ContainsStringValueFilter, getFields, EntityRef, getEntityRef, SortSegments, ValueListFieldType, getValueList, ValueListFieldOptions, ValueListInfo, OmitEB, Paginator, CaptionTransformer } from './src/remult3';
+export { Field, Fields, FieldsMetadata, Entity, EntityBase, ControllerBase, FieldRef, IdFieldRef, FieldsRef, EntityMetadata, EntityOrderBy, EntityFilter, FindOptions, QueryResult, QueryOptions, Repository, FieldType, FindFirstOptions, ComparisonValueFilter, ValueFilter, IdFilter, ContainsStringValueFilter, getFields, EntityRef, getEntityRef, SortSegments, ValueListFieldType, getValueList, ValueListFieldOptions, ValueListInfo, OmitEB, Paginator, CaptionTransformer, LiveQuery, LiveQueryChangeInfo } from './src/remult3';
 export { StringFieldOptions } from './src/remult3/RepositoryImplementation';
 export { describeClass } from './src/remult3/DecoratorReplacer';
 export { EntityOptions } from './src/entity';
@@ -11,7 +11,7 @@ export { InMemoryDataProvider } from './src/data-providers/in-memory-database';
 export { ArrayEntityDataProvider } from './src/data-providers/array-entity-data-provider';
 export { WebSqlDataProvider } from './src/data-providers/web-sql-data-provider';
 export { SqlDatabase, } from './src/data-providers/sql-database';
-export { CustomSqlFilterObject, CustomSqlFilterBuilder } from './src/filter/filter-consumer-bridge-to-sql-request';
+export { 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, Unobserve, UserInfo } from './src/context';
@@ -20,8 +20,9 @@ export { IdEntity } from './src/id-entity';
 export { SortSegment, Sort } from './src/sort';
 export { OneToMany, CompoundIdField } from './src/column';
 export { Filter } from './src/filter/filter-interfaces';
-export { FilterConsumerBridgeToSqlRequest } from './src/filter/filter-consumer-bridge-to-sql-request';
 export { UrlBuilder } from './urlBuilder';
 export { Validators } from './src/validators';
 export { ValueConverters } from './src/valueConverters';
 export { remult } from './src/remult-proxy';
+export { SubscriptionServer, LiveQueryStorage, StoredQuery, InMemoryLiveQueryStorage } from "./src/live-query/SubscriptionServer";
+export { SubscriptionListener, SubscriptionClientConnection, SubscriptionClient, SubscriptionChannel, LiveQueryChange, Unsubscribe } from './src/live-query/SubscriptionChannel';

package/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.remult = exports.ValueConverters = exports.Validators = exports.UrlBuilder = exports.FilterConsumerBridgeToSqlRequest = exports.Filter = exports.CompoundIdField = exports.OneToMany = exports.Sort = exports.IdEntity = exports.EventSource = exports.isBackend = exports.Remult = exports.Allow = exports.ProgressListener = exports.BackendMethod = exports.Controller = exports.JsonDataProvider = exports.CustomSqlFilterBuilder = exports.SqlDatabase = exports.WebSqlDataProvider = exports.ArrayEntityDataProvider = exports.InMemoryDataProvider = exports.RestDataProvider = exports.describeClass = exports.CaptionTransformer = exports.ValueListInfo = exports.getValueList = exports.ValueListFieldType = exports.getEntityRef = exports.getFields = exports.FieldType = exports.ControllerBase = exports.EntityBase = exports.Entity = exports.Fields = exports.Field = void 0;
+exports.SubscriptionChannel = exports.InMemoryLiveQueryStorage = exports.remult = exports.ValueConverters = exports.Validators = exports.UrlBuilder = exports.Filter = exports.CompoundIdField = exports.OneToMany = exports.Sort = exports.IdEntity = exports.EventSource = exports.isBackend = exports.Remult = exports.Allow = exports.ProgressListener = exports.BackendMethod = exports.Controller = exports.JsonDataProvider = exports.dbNamesOf = exports.CustomSqlFilterBuilder = exports.SqlDatabase = exports.WebSqlDataProvider = exports.ArrayEntityDataProvider = exports.InMemoryDataProvider = exports.RestDataProvider = exports.describeClass = exports.CaptionTransformer = exports.ValueListInfo = exports.getValueList = exports.ValueListFieldType = exports.getEntityRef = exports.getFields = exports.FieldType = exports.ControllerBase = exports.EntityBase = exports.Entity = exports.Fields = exports.Field = void 0;
 /*
  * Public API Surface of remult
  */
@@ -31,6 +31,7 @@ var sql_database_1 = require("./src/data-providers/sql-database"); //V
 Object.defineProperty(exports, "SqlDatabase", { enumerable: true, get: function () { return sql_database_1.SqlDatabase; } });
 var filter_consumer_bridge_to_sql_request_1 = require("./src/filter/filter-consumer-bridge-to-sql-request");
 Object.defineProperty(exports, "CustomSqlFilterBuilder", { enumerable: true, get: function () { return filter_consumer_bridge_to_sql_request_1.CustomSqlFilterBuilder; } });
+Object.defineProperty(exports, "dbNamesOf", { enumerable: true, get: function () { return filter_consumer_bridge_to_sql_request_1.dbNamesOf; } });
 var json_data_provider_1 = require("./src/data-providers/json-data-provider"); //V
 Object.defineProperty(exports, "JsonDataProvider", { enumerable: true, get: function () { return json_data_provider_1.JsonDataProvider; } });
 //export * from './src/data-api'; //reconsider if to make internal
@@ -52,8 +53,6 @@ Object.defineProperty(exports, "OneToMany", { enumerable: true, get: function ()
 Object.defineProperty(exports, "CompoundIdField", { enumerable: true, get: function () { return column_1.CompoundIdField; } });
 var filter_interfaces_1 = require("./src/filter/filter-interfaces");
 Object.defineProperty(exports, "Filter", { enumerable: true, get: function () { return filter_interfaces_1.Filter; } });
-var filter_consumer_bridge_to_sql_request_2 = require("./src/filter/filter-consumer-bridge-to-sql-request");
-Object.defineProperty(exports, "FilterConsumerBridgeToSqlRequest", { enumerable: true, get: function () { return filter_consumer_bridge_to_sql_request_2.FilterConsumerBridgeToSqlRequest; } });
 var urlBuilder_1 = require("./urlBuilder");
 Object.defineProperty(exports, "UrlBuilder", { enumerable: true, get: function () { return urlBuilder_1.UrlBuilder; } });
 var validators_1 = require("./src/validators");
@@ -62,3 +61,8 @@ var valueConverters_1 = require("./src/valueConverters");
 Object.defineProperty(exports, "ValueConverters", { enumerable: true, get: function () { return valueConverters_1.ValueConverters; } });
 var remult_proxy_1 = require("./src/remult-proxy");
 Object.defineProperty(exports, "remult", { enumerable: true, get: function () { return remult_proxy_1.remult; } });
+//export { getId } from './src/remult3/getId';
+var SubscriptionServer_1 = require("./src/live-query/SubscriptionServer");
+Object.defineProperty(exports, "InMemoryLiveQueryStorage", { enumerable: true, get: function () { return SubscriptionServer_1.InMemoryLiveQueryStorage; } });
+var SubscriptionChannel_1 = require("./src/live-query/SubscriptionChannel");
+Object.defineProperty(exports, "SubscriptionChannel", { enumerable: true, get: function () { return SubscriptionChannel_1.SubscriptionChannel; } });

package/live-query/ably.d.ts

@@ -1,13 +1,13 @@
 import type * as Ably from 'ably';
-import type { ServerEventDispatcher } from '../src/live-query/LiveQueryPublisher';
-import type { LiveQueryProvider, PubSubClient } from '../src/live-query/LiveQuerySubscriber';
-export declare class AblyLiveQueryProvider implements LiveQueryProvider {
+import type { SubscriptionServer } from '../src/live-query/SubscriptionServer';
+import type { SubscriptionClient, SubscriptionClientConnection } from '../src/live-query/SubscriptionChannel';
+export declare class AblySubscriptionClient implements SubscriptionClient {
     private ably;
     constructor(ably: Ably.Types.RealtimePromise);
-    openStreamAndReturnCloseFunction(onReconnect: VoidFunction): Promise<PubSubClient>;
+    openConnection(onReconnect: VoidFunction): Promise<SubscriptionClientConnection>;
 }
-export declare class AblyServerEventDispatcher implements ServerEventDispatcher {
+export declare class AblySubscriptionServer implements SubscriptionServer {
     private ably;
     constructor(ably: Ably.Types.RealtimePromise);
-    sendChannelMessage<T>(channel: string, message: T): void;
+    publishMessage<T>(channel: string, message: T): void;
 }

package/live-query/ably.js

@@ -1,17 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AblyServerEventDispatcher = exports.AblyLiveQueryProvider = void 0;
+exports.AblySubscriptionServer = exports.AblySubscriptionClient = void 0;
 var tslib_1 = require("tslib");
-var AblyLiveQueryProvider = /** @class */ (function () {
-    function AblyLiveQueryProvider(ably) {
+var AblySubscriptionClient = /** @class */ (function () {
+    function AblySubscriptionClient(ably) {
         this.ably = ably;
     }
-    AblyLiveQueryProvider.prototype.openStreamAndReturnCloseFunction = function (onReconnect) {
+    AblySubscriptionClient.prototype.openConnection = function (onReconnect) {
         return tslib_1.__awaiter(this, void 0, void 0, function () {
             var _this = this;
             return tslib_1.__generator(this, function (_a) {
                 return [2 /*return*/, {
-                        disconnect: function () {
+                        close: function () {
                             _this.ably.connection.close();
                         },
                         subscribe: function (channel, handler) {
@@ -23,16 +23,16 @@ var AblyLiveQueryProvider = /** @class */ (function () {
             });
         });
     };
-    return AblyLiveQueryProvider;
+    return AblySubscriptionClient;
 }());
-exports.AblyLiveQueryProvider = AblyLiveQueryProvider;
-var AblyServerEventDispatcher = /** @class */ (function () {
-    function AblyServerEventDispatcher(ably) {
+exports.AblySubscriptionClient = AblySubscriptionClient;
+var AblySubscriptionServer = /** @class */ (function () {
+    function AblySubscriptionServer(ably) {
         this.ably = ably;
     }
-    AblyServerEventDispatcher.prototype.sendChannelMessage = function (channel, message) {
+    AblySubscriptionServer.prototype.publishMessage = function (channel, message) {
         this.ably.channels.get(channel).publish({ data: message });
     };
-    return AblyServerEventDispatcher;
+    return AblySubscriptionServer;
 }());
-exports.AblyServerEventDispatcher = AblyServerEventDispatcher;
+exports.AblySubscriptionServer = AblySubscriptionServer;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "remult",
-    "version": "0.18.1-exp.2",
+    "version": "0.18.1-exp.21",
     "description": "A CRUD framework for full-stack TypeScript",
     "main": "index.js",
     "types": "index.d.ts",
@@ -17,6 +17,7 @@
     },
     "dependencies": {
         "uuid": "^8.3.2",
+        "cuid": "^2.1.8",
         "reflect-metadata": "^0.1.13",
         "tslib": "^2.3.1"
     },
@@ -37,6 +38,14 @@
             },
             "import": "./esm/remult-express.js"
         },
+        "./remult-next": {
+            "require": "./remult-next.js",
+            "node": {
+                "require": "./remult-next.js",
+                "import": "./remult-next.js"
+            },
+            "import": "./esm/remult-next.js"
+        },
         "./server": {
             "require": "./server/index.js",
             "node": {
@@ -45,6 +54,14 @@
             },
             "import": "./esm/server/index.js"
         },
+        "./server/core": {
+            "require": "./server/core.js",
+            "node": {
+                "require": "./server/core.js",
+                "import": "./server/core.js"
+            },
+            "import": "./esm/server/core.js"
+        },
         "./remult-fastify": {
             "require": "./remult-fastify.js",
             "node": {
@@ -93,14 +110,6 @@
             },
             "import": "./esm/remult-mongo.js"
         },
-        "./live-query": {
-            "require": "./live-query/index.js",
-            "node": {
-                "require": "./live-query/index.js",
-                "import": "./live-query/index.js"
-            },
-            "import": "./esm/live-query/index.js"
-        },
         "./live-query/ably": {
             "require": "./live-query/ably.js",
             "node": {

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

@@ -1,4 +1,5 @@
-import { PoolConfig, QueryResult } from 'pg';
+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';
@@ -10,6 +11,7 @@ export interface PostgresClient extends PostgresCommandSource {
 }
 export declare class PostgresDataProvider implements SqlImplementation {
     private pool;
+    static getDb(remult?: Remult): ClientBase;
     entityIsUsedForTheFirstTime(entity: EntityMetadata): Promise<void>;
     getLimitSqlSyntax(limit: number, offset: number): string;
     createCommand(): SqlCommand;

package/postgres/postgres-data-provider.js

@@ -10,6 +10,14 @@ var PostgresDataProvider = /** @class */ (function () {
     function PostgresDataProvider(pool) {
         this.pool = pool;
     }
+    PostgresDataProvider.getDb = function (remult) {
+        var sql = sql_database_1.SqlDatabase.getDb(remult);
+        var me = sql._getSourceSql();
+        if (!me.pool) {
+            throw "the data provider is not a PostgresDataProvider";
+        }
+        return me.pool;
+    };
     PostgresDataProvider.prototype.entityIsUsedForTheFirstTime = function (entity) {
         return tslib_1.__awaiter(this, void 0, void 0, function () {
             return tslib_1.__generator(this, function (_a) {
@@ -41,7 +49,9 @@ var PostgresDataProvider = /** @class */ (function () {
                                 createCommand: function () { return new PostgresBridgeToSQLCommand(client); },
                                 entityIsUsedForTheFirstTime: this.entityIsUsedForTheFirstTime,
                                 transaction: function () { throw "nested transactions not allowed"; },
-                                getLimitSqlSyntax: this.getLimitSqlSyntax
+                                getLimitSqlSyntax: this.getLimitSqlSyntax,
+                                //@ts-ignore
+                                pool: client
                             })];
                     case 4:
                         _a.sent();
@@ -140,7 +150,7 @@ function preparePostgresQueueStorage(sql) {
                 case 0:
                     c = new context_1.Remult();
                     c.dataProvider = (sql);
-                    return [4 /*yield*/, Promise.resolve().then(function () { return require('../server/expressBridge'); })];
+                    return [4 /*yield*/, Promise.resolve().then(function () { return tslib_1.__importStar(require('../server/expressBridge')); })];
                 case 1:
                     JobsInQueueEntity = (_a.sent()).JobsInQueueEntity;
                     e = c.repo(JobsInQueueEntity);
@@ -150,7 +160,7 @@ function preparePostgresQueueStorage(sql) {
                     return [4 /*yield*/, new schema_builder_1.PostgresSchemaBuilder(sql).verifyAllColumns(e.metadata)];
                 case 3:
                     _a.sent();
-                    return [4 /*yield*/, Promise.resolve().then(function () { return require('../server/expressBridge'); })];
+                    return [4 /*yield*/, Promise.resolve().then(function () { return tslib_1.__importStar(require('../server/expressBridge')); })];
                 case 4: return [2 /*return*/, new (_a.sent()).EntityQueueStorage(c.repo(JobsInQueueEntity))];
             }
         });

package/postgres/schema-builder.d.ts

@@ -6,7 +6,7 @@ export declare function postgresColumnSyntax(x: FieldMetadata, dbName: string):
 export declare function verifyStructureOfAllEntities(db: SqlDatabase, remult: Remult): Promise<void>;
 export declare class PostgresSchemaBuilder {
     private pool;
-    verifyStructureOfAllEntities(remult: Remult): Promise<void>;
+    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>;