remult 0.17.2 → 0.18.0

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

@@ -0,0 +1,236 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataProviderLiveQueryStorage = void 0;
+var tslib_1 = require("tslib");
+var initDataProvider_1 = require("../server/initDataProvider");
+var context_1 = require("../src/context");
+var remult3_1 = require("../src/remult3");
+var DataProviderLiveQueryStorage = /** @class */ (function () {
+    function DataProviderLiveQueryStorage(dataProvider) {
+        this.dataProvider = initDataProvider_1.initDataProvider(dataProvider);
+        this.repo = this.dataProvider.then(function (dp) {
+            return new context_1.Remult(dp).repo(LiveQueryStorageEntity);
+        });
+    }
+    DataProviderLiveQueryStorage.prototype.ensureSchema = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var _a, _b;
+            return tslib_1.__generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0: return [4 /*yield*/, this.dataProvider];
+                    case 1:
+                        _b = (_a = (_c.sent())).ensureSchema;
+                        return [4 /*yield*/, this.repo];
+                    case 2: return [4 /*yield*/, _b.apply(_a, [[(_c.sent()).metadata]])];
+                    case 3:
+                        _c.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    DataProviderLiveQueryStorage.prototype.add = function (_a) {
+        var id = _a.id, entityKey = _a.entityKey, data = _a.data;
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return tslib_1.__generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this.repo.then(function (repo) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                            var q;
+                            return tslib_1.__generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, repo.findId(id, { createIfNotFound: true })];
+                                    case 1:
+                                        q = _a.sent();
+                                        return [4 /*yield*/, q.assign({ entityKey: entityKey, data: data }).save()];
+                                    case 2:
+                                        _a.sent();
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); })];
+                    case 1:
+                        _b.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    DataProviderLiveQueryStorage.prototype.remove = function (queryId) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.repo.then(function (repo) { return repo.delete(queryId); }).catch(function () { })];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    DataProviderLiveQueryStorage.prototype.forEach = function (entityKey, callback) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var repo, d, iso, _loop_1, _a, _b, query, e_1_1;
+            var e_1, _c;
+            var _this = this;
+            return tslib_1.__generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0: return [4 /*yield*/, this.repo];
+                    case 1:
+                        repo = _d.sent();
+                        d = new Date();
+                        d.setMinutes(d.getMinutes() - 5);
+                        iso = d.toISOString();
+                        _loop_1 = function (query) {
+                            return tslib_1.__generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        if (!(query.lastUsedIso < iso)) return [3 /*break*/, 2];
+                                        return [4 /*yield*/, repo.delete(query)];
+                                    case 1:
+                                        _a.sent();
+                                        return [3 /*break*/, 4];
+                                    case 2: return [4 /*yield*/, callback({
+                                            query: query, setData: function (data) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                                                return tslib_1.__generator(this, function (_a) {
+                                                    switch (_a.label) {
+                                                        case 0:
+                                                            query.data = data;
+                                                            return [4 /*yield*/, repo.save(query)];
+                                                        case 1:
+                                                            _a.sent();
+                                                            return [2 /*return*/];
+                                                    }
+                                                });
+                                            }); },
+                                        })];
+                                    case 3:
+                                        _a.sent();
+                                        _a.label = 4;
+                                    case 4: return [2 /*return*/];
+                                }
+                            });
+                        };
+                        _d.label = 2;
+                    case 2:
+                        _d.trys.push([2, 8, 9, 10]);
+                        return [4 /*yield*/, repo.find({ where: { entityKey: entityKey } })];
+                    case 3:
+                        _a = tslib_1.__values.apply(void 0, [_d.sent()]), _b = _a.next();
+                        _d.label = 4;
+                    case 4:
+                        if (!!_b.done) return [3 /*break*/, 7];
+                        query = _b.value;
+                        return [5 /*yield**/, _loop_1(query)];
+                    case 5:
+                        _d.sent();
+                        _d.label = 6;
+                    case 6:
+                        _b = _a.next();
+                        return [3 /*break*/, 4];
+                    case 7: return [3 /*break*/, 10];
+                    case 8:
+                        e_1_1 = _d.sent();
+                        e_1 = { error: e_1_1 };
+                        return [3 /*break*/, 10];
+                    case 9:
+                        try {
+                            if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                        return [7 /*endfinally*/];
+                    case 10: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    DataProviderLiveQueryStorage.prototype.keepAliveAndReturnUnknownQueryIds = function (queryIds) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var repo, _loop_2, _a, _b, query, e_2_1;
+            var e_2, _c;
+            return tslib_1.__generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0: return [4 /*yield*/, this.repo];
+                    case 1:
+                        repo = _d.sent();
+                        _loop_2 = function (query) {
+                            return tslib_1.__generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        query.lastUsedIso = new Date().toISOString();
+                                        return [4 /*yield*/, repo.save(query)];
+                                    case 1:
+                                        _a.sent();
+                                        queryIds = queryIds.filter(function (x) { return x !== query.id; });
+                                        return [2 /*return*/];
+                                }
+                            });
+                        };
+                        _d.label = 2;
+                    case 2:
+                        _d.trys.push([2, 8, 9, 10]);
+                        return [4 /*yield*/, repo.find({ where: { id: queryIds } })];
+                    case 3:
+                        _a = tslib_1.__values.apply(void 0, [_d.sent()]), _b = _a.next();
+                        _d.label = 4;
+                    case 4:
+                        if (!!_b.done) return [3 /*break*/, 7];
+                        query = _b.value;
+                        return [5 /*yield**/, _loop_2(query)];
+                    case 5:
+                        _d.sent();
+                        _d.label = 6;
+                    case 6:
+                        _b = _a.next();
+                        return [3 /*break*/, 4];
+                    case 7: return [3 /*break*/, 10];
+                    case 8:
+                        e_2_1 = _d.sent();
+                        e_2 = { error: e_2_1 };
+                        return [3 /*break*/, 10];
+                    case 9:
+                        try {
+                            if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                        }
+                        finally { if (e_2) throw e_2.error; }
+                        return [7 /*endfinally*/];
+                    case 10: return [2 /*return*/, queryIds];
+                }
+            });
+        });
+    };
+    return DataProviderLiveQueryStorage;
+}());
+exports.DataProviderLiveQueryStorage = DataProviderLiveQueryStorage;
+var LiveQueryStorageEntity = /** @class */ (function (_super) {
+    tslib_1.__extends(LiveQueryStorageEntity, _super);
+    function LiveQueryStorageEntity() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.id = '';
+        _this.entityKey = '';
+        _this.lastUsedIso = new Date().toISOString();
+        return _this;
+    }
+    tslib_1.__decorate([
+        remult3_1.Fields.string(),
+        tslib_1.__metadata("design:type", Object)
+    ], LiveQueryStorageEntity.prototype, "id", void 0);
+    tslib_1.__decorate([
+        remult3_1.Fields.string(),
+        tslib_1.__metadata("design:type", Object)
+    ], LiveQueryStorageEntity.prototype, "entityKey", void 0);
+    tslib_1.__decorate([
+        remult3_1.Fields.object(),
+        tslib_1.__metadata("design:type", Object)
+    ], LiveQueryStorageEntity.prototype, "data", void 0);
+    tslib_1.__decorate([
+        remult3_1.Fields.string(),
+        tslib_1.__metadata("design:type", Object)
+    ], LiveQueryStorageEntity.prototype, "lastUsedIso", void 0);
+    LiveQueryStorageEntity = tslib_1.__decorate([
+        remult3_1.Entity(undefined, {
+            dbName: 'remult_live_query_storage'
+        })
+    ], LiveQueryStorageEntity);
+    return LiveQueryStorageEntity;
+}(remult3_1.EntityBase));

package/myLog.d.ts

@@ -0,0 +1 @@
+export declare function writeToLog(what: any): Promise<void>;

package/myLog.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeToLog = void 0;
+var tslib_1 = require("tslib");
+function writeToLog(what) {
+    return tslib_1.__awaiter(this, void 0, void 0, function () {
+        return tslib_1.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (typeof what !== "string")
+                        what = JSON.stringify(what, undefined, 2);
+                    return [4 /*yield*/, (Promise.resolve().then(function () { return tslib_1.__importStar(require('fs')); }))];
+                case 1:
+                    (_a.sent()).appendFileSync('./tmp/test.log', what + '\n');
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+exports.writeToLog = writeToLog;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "remult",
-    "version": "0.17.2",
+    "version": "0.18.0",
     "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": {
@@ -101,6 +110,14 @@
             },
             "import": "./esm/remult-mongo.js"
         },
+        "./ably": {
+            "require": "./ably.js",
+            "node": {
+                "require": "./ably.js",
+                "import": "./ably.js"
+            },
+            "import": "./esm/ably.js"
+        },
         "./graphql": {
             "require": "./graphql.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,10 +11,12 @@ 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;
     constructor(pool: PostgresPool);
+    ensureSchema(entities: EntityMetadata<any>[]): Promise<void>;
     transaction(action: (dataProvider: SqlImplementation) => Promise<void>): Promise<void>;
 }
 export interface PostgresCommandSource {
@@ -23,6 +26,5 @@ export declare function createPostgresConnection(options?: {
     connectionString?: string;
     sslInDev?: boolean;
     configuration?: "heroku" | PoolConfig;
-    autoCreateTables?: boolean;
 }): Promise<SqlDatabase>;
 export declare function preparePostgresQueueStorage(sql: SqlDatabase): Promise<import("../server/expressBridge").EntityQueueStorage>;

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) {
@@ -23,6 +31,22 @@ var PostgresDataProvider = /** @class */ (function () {
     PostgresDataProvider.prototype.createCommand = function () {
         return new PostgresBridgeToSQLCommand(this.pool);
     };
+    PostgresDataProvider.prototype.ensureSchema = function (entities) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var db, sb;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        db = new sql_database_1.SqlDatabase(this);
+                        sb = new schema_builder_1.PostgresSchemaBuilder(db);
+                        return [4 /*yield*/, sb.ensureSchema(entities)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
     PostgresDataProvider.prototype.transaction = function (action) {
         return tslib_1.__awaiter(this, void 0, void 0, function () {
             var client, err_1;
@@ -41,7 +65,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();
@@ -95,39 +121,31 @@ function createPostgresConnection(options) {
     return tslib_1.__awaiter(this, void 0, void 0, function () {
         var config, db, remult;
         return tslib_1.__generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    if (!options)
-                        options = {};
-                    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
-                                }
-                            };
+            if (!options)
+                options = {};
+            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;
-                    }
-                    db = new sql_database_1.SqlDatabase(new PostgresDataProvider(new pg_1.Pool(config)));
-                    remult = new context_1.Remult();
-                    remult.dataProvider = (db);
-                    if (!(options.autoCreateTables === undefined || options.autoCreateTables)) return [3 /*break*/, 2];
-                    return [4 /*yield*/, schema_builder_1.verifyStructureOfAllEntities(db, remult)];
-                case 1:
-                    _a.sent();
-                    _a.label = 2;
-                case 2: return [2 /*return*/, db];
+                    };
+                }
+                else
+                    config = options.configuration;
+            else {
+                if (!options.connectionString)
+                    options.connectionString = process.env.DATABASE_URL;
             }
+            if (!config.connectionString && options.connectionString) {
+                config.connectionString = options.connectionString;
+            }
+            db = new sql_database_1.SqlDatabase(new PostgresDataProvider(new pg_1.Pool(config)));
+            remult = new context_1.Remult();
+            remult.dataProvider = (db);
+            return [2 /*return*/, db];
         });
     });
 }
@@ -140,18 +158,15 @@ 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);
-                    return [4 /*yield*/, new schema_builder_1.PostgresSchemaBuilder(sql).createIfNotExist(e.metadata)];
+                    return [4 /*yield*/, sql.ensureSchema([e.metadata])];
                 case 2:
                     _a.sent();
-                    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'); })];
-                case 4: return [2 /*return*/, new (_a.sent()).EntityQueueStorage(c.repo(JobsInQueueEntity))];
+                    return [4 /*yield*/, Promise.resolve().then(function () { return tslib_1.__importStar(require('../server/expressBridge')); })];
+                case 3: return [2 /*return*/, new (_a.sent()).EntityQueueStorage(c.repo(JobsInQueueEntity))];
             }
         });
     });

package/postgres/schema-builder.d.ts

@@ -6,7 +6,8 @@ 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>;
+    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>;