remult 0.27.11 → 0.27.13

package/esm/index.js

@@ -7,7 +7,6 @@ export { IdEntity } from './src/remult3/IdEntity.js';
 export { describeClass, describeBackendMethods, describeEntity, } from './src/remult3/classDescribers.js';
 export { RestDataProvider } from './src/data-providers/rest-data-provider.js'; //V
 export { InMemoryDataProvider } from './src/data-providers/in-memory-database.js'; //V
-export { WebSqlDataProvider } from './src/data-providers/web-sql-data-provider.js'; //V
 export { SqlDatabase } from './src/data-providers/sql-database.js'; //V
 export { CustomSqlFilterBuilder, dbNamesOf, } from './src/filter/filter-consumer-bridge-to-sql-request.js';
 export { JsonDataProvider, } from './src/data-providers/json-data-provider.js'; //V

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

@@ -3,7 +3,6 @@ import { Remult } from '../src/context.js';
 import { EntityBase } from '../src/remult3/RepositoryImplementation.js';
 import { Fields } from '../src/remult3/Fields.js';
 import { Entity } from '../src/remult3/entity.js';
-import { remultStatic } from '../src/remult-static.js';
 import { initDataProviderOrJson } from '../server/initDataProviderOrJson.js';
 export class DataProviderLiveQueryStorage {
     repo;
@@ -90,4 +89,3 @@ LiveQueryStorageEntity = __decorate([
     /*@internal */
 ], LiveQueryStorageEntity);
 export { LiveQueryStorageEntity };
-remultStatic.allEntities.splice(remultStatic.allEntities.indexOf(LiveQueryStorageEntity), 1);

package/esm/postgres/schema-builder.js

@@ -1,6 +1,4 @@
 import { dbNamesOf, shouldCreateEntity, shouldNotCreateField, } from '../src/filter/filter-consumer-bridge-to-sql-request.js';
-import { remult as defaultRemult } from '../src/remult-proxy.js';
-import { remultStatic } from '../src/remult-static.js';
 import { isAutoIncrement } from '../src/remult3/RepositoryImplementation.js';
 import { ValueConverters } from '../src/valueConverters.js';
 export function postgresColumnSyntax(x, dbName) {
@@ -35,9 +33,6 @@ export function postgresColumnSyntax(x, dbName) {
         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
@@ -89,22 +84,6 @@ export class PostgresSchemaBuilder {
         // Should default to `public`
         return 'public';
     }
-    async verifyStructureOfAllEntities(remult) {
-        if (!remult) {
-            remult = defaultRemult;
-        }
-        const completed = new Set();
-        const entities = [];
-        for (const entityClass of [...remultStatic.allEntities].reverse()) {
-            let entity = remult.repo(entityClass).metadata;
-            let e = await dbNamesOf(entity, this.pool.wrapIdentifier);
-            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, this.pool.wrapIdentifier);
@@ -164,26 +143,6 @@ export class PostgresSchemaBuilder {
 CREATE table ${this.schemaAndName(e)} (${result}\r\n)`;
         return sql;
     }
-    async addColumnIfNotExist(entity, c) {
-        let e = await dbNamesOf(entity, this.pool.wrapIdentifier);
-        if (shouldNotCreateField(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 ` +
-                `${this.whereTableAndSchema(cmd, e)} ` +
-                `AND column_name=${cmd.param(colName.toLocaleLowerCase())}`)).rows.length == 0) {
-                let sql = await this.getAddColumnScript(entity, c(entity));
-                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();

package/esm/remult-duckdb.js

@@ -33,13 +33,13 @@ export class DuckDBDataProvider extends SqliteCoreDataProvider {
             .join(',')})`;
         sql +=
             'create table if not exists ' + e.$entityName + ' (' + result + '\r\n)';
-        return sql;
+        return [sql];
     }
     addColumnSqlSyntax(x, dbName, isAlterColumn) {
         let result = dbName;
         var allowNull = x.allowNull;
-        if (allowNull && isAlterColumn) {
-            allowNull = false;
+        if (!allowNull && isAlterColumn) {
+            allowNull = true;
             console.log('DuckDB does not support altering columns to allow null on existing tables');
         }
         if (x.valueType == Number) {
@@ -49,7 +49,7 @@ export class DuckDBDataProvider extends SqliteCoreDataProvider {
                 result +=
                     ' ' +
                         x.valueConverter.fieldTypeInDb +
-                        (x.allowNull || isAlterColumn ? '' : ' default 0 not null');
+                        (allowNull ? '' : ' default 0 not null');
         }
         else if (x.valueType == Date) {
             if (!x.valueConverter.fieldTypeInDb)
@@ -61,20 +61,15 @@ export class DuckDBDataProvider extends SqliteCoreDataProvider {
                 result += ' ' + x.valueConverter.fieldTypeInDb;
         }
         else if (x.valueType == Boolean)
-            result +=
-                ' boolean' +
-                    (x.allowNull || isAlterColumn ? '' : ' default false not null');
+            result += ' boolean' + (allowNull ? '' : ' default false not null');
         else if (x.valueConverter.fieldTypeInDb) {
             result += ' ' + x.valueConverter.fieldTypeInDb;
-            if (!(x.allowNull || isAlterColumn) &&
-                x.valueConverter.fieldTypeInDb == 'integer') {
+            if (!allowNull && x.valueConverter.fieldTypeInDb == 'integer') {
                 result += ' default 0 not null';
             }
         }
         else
-            result +=
-                ' varchar' +
-                    (x.allowNull || isAlterColumn ? '' : " default '' not null");
+            result += ' varchar' + (allowNull ? '' : " default '' not null");
         return result;
     }
 }

package/esm/remult-knex/index.js

@@ -6,7 +6,6 @@ import { getRepository, isAutoIncrement, } from '../src/remult3/RepositoryImplem
 import { Sort } from '../src/sort.js';
 import { ValueConverters } from '../src/valueConverters.js';
 import { getRepositoryInternals } from '../src/remult3/repository-internals.js';
-import { remultStatic } from '../src/remult-static.js';
 import { groupByImpl, getRowAfterUpdate, } from '../src/data-providers/sql-database.js';
 export class KnexDataProvider {
     knex;
@@ -415,12 +414,6 @@ export class KnexSchemaBuilder {
     knex;
     //@internal
     static logToConsole = true;
-    async verifyStructureOfAllEntities(remult) {
-        if (!remult)
-            remult = remultContext;
-        const entities = remultStatic.allEntities.map((x) => remult.repo(x).metadata);
-        await this.ensureSchema(entities);
-    }
     async ensureSchema(entities) {
         for (const entity of entities) {
             let e = await dbNamesOf(entity, (x) => x);

package/esm/remult-mongo.js

@@ -23,6 +23,12 @@ export class MongoDataProvider {
             throw 'the data provider is not a MongoDataProvider';
         return { db: r.db, session: r.session };
     }
+    async ensureSchema(entities) {
+        for (const entity of entities) {
+            const m = new MongoEntityDataProvider(this.db, entity, this.session);
+            await m.ensureSchema();
+        }
+    }
     getEntityDataProvider(entity) {
         return new MongoEntityDataProvider(this.db, entity, this.session);
     }
@@ -66,6 +72,25 @@ class MongoEntityDataProvider {
     db;
     entity;
     session;
+    async ensureSchema() {
+        const { collection, e } = await this.collection();
+        if (!(await this.db.collections()).find((x) => x.collectionName == e.$entityName)) {
+            await this.db.createCollection(e.$entityName);
+            if (this.entity.idMetadata.field &&
+                e.$dbNameOf(this.entity.idMetadata.field) != '_id') {
+                const index = {};
+                for (const f of this.entity.idMetadata.fields) {
+                    index[e.$dbNameOf(f)] = 1;
+                }
+                try {
+                    await collection.createIndex(index, { unique: true });
+                }
+                catch (err) {
+                    throw err;
+                }
+            }
+        }
+    }
     constructor(db, entity, session) {
         this.db = db;
         this.entity = entity;
@@ -75,6 +100,14 @@ class MongoEntityDataProvider {
         let result = {};
         for (const col of this.entity.fields) {
             let val = row[nameProvider.$dbNameOf(col)];
+            if (val === undefined) {
+                if (!col.allowNull) {
+                    if (col.valueType === String)
+                        val = '';
+                }
+                else
+                    val = null;
+            }
             if (isNull(val))
                 val = null;
             result[col.key] = fromDb(col, val);

package/esm/remult-sqlite-core.js

@@ -21,7 +21,7 @@ export class SqliteCoreDataProvider {
         let self = this;
         return {
             createTable: async (entity) => {
-                builder.addSql(await self.getCreateTableSql(entity));
+                await (await self.getCreateTableSql(entity)).map(builder.addSql);
             },
             addColumn: async (entity, field) => {
                 let e = await dbNamesOf(entity, this.wrapIdentifier);
@@ -45,6 +45,27 @@ export class SqliteCoreDataProvider {
     async ensureSchema(entities) {
         for (const entity of entities) {
             await this.createTableIfNotExist(entity);
+            await this.verifyAllColumns(entity);
+        }
+    }
+    async verifyAllColumns(entity) {
+        try {
+            let cmd = this.createCommand();
+            let e = await dbNamesOf(entity, this.wrapIdentifier);
+            let cols = (await cmd.execute(`PRAGMA table_info(${e.$entityName})`)).rows.map((x) => this.wrapIdentifier(x.name.toLocaleLowerCase()));
+            for (const col of entity.fields) {
+                if (!shouldNotCreateField(col, e)) {
+                    let colName = e.$dbNameOf(col).toLocaleLowerCase();
+                    if (!cols.includes(colName)) {
+                        let sql = `ALTER table ${e.$entityName} ` +
+                            `add column ${this.addColumnSqlSyntax(col, e.$dbNameOf(col), true)}`;
+                        await this.createCommand().execute(sql);
+                    }
+                }
+            }
+        }
+        catch (err) {
+            console.error(err);
         }
     }
     async dropTable(entity) {
@@ -73,9 +94,9 @@ export class SqliteCoreDataProvider {
     }
     async createTableIfNotExist(entity) {
         let sql = await this.getCreateTableSql(entity);
-        if (SqlDatabase.LogToConsole)
-            console.log(sql);
-        await this.createCommand().execute(sql);
+        for (const element of sql) {
+            await this.createCommand().execute(element);
+        }
     }
     supportsJsonColumnType;
     async getCreateTableSql(entity) {
@@ -99,7 +120,14 @@ export class SqliteCoreDataProvider {
                 }
             }
         }
-        let sql = 'create table if not exists ' + e.$entityName + ' (' + result + '\r\n)';
+        let sql = [
+            'create table if not exists ' + e.$entityName + ' (' + result + '\r\n)',
+        ];
+        if (entity.idMetadata.fields.length > 1) {
+            sql.push(`create unique index ${this.wrapIdentifier(entity.dbName + '_primary_key')} on ${e.$entityName}  (${entity.idMetadata.fields
+                .map((x) => e.$dbNameOf(x))
+                .join(',')})`);
+        }
         return sql;
     }
     wrapIdentifier(name) {