remult 0.24.1 → 0.24.2-exp.1

package/README.md

@@ -27,9 +27,9 @@
 <br/>
 
 <div align="center">
-  <a href="#getting-started">Getting Started</a> |
-  <a href="#documentation">Documentation</a> |
-  <a href="#example-apps">Example Apps</a>
+  <a href="#tutorials">Tutorials</a> |
+  <a href="https://remult.dev/docs/quickstart">Quickstart</a> |
+  <a href="https://remult.dev/docs/example-apps">Example Apps</a>
 </div>
 
 <hr/>
@@ -268,7 +268,7 @@ numerous ways:
   [Backend Methods](https://remult.dev/docs/backendMethods.html)
 - Roll-your-own low-level endpoints (Express, Fastify, koa, others…)
 
-## Getting started
+## Tutorials
 
 The best way to learn Remult is by following a tutorial of a simple Todo web app
 with a Node.js Express backend.

package/esm/index.js

@@ -10,6 +10,7 @@ export { WebSqlDataProvider } from './src/data-providers/web-sql-data-provider.j
 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
+export { JsonEntityOpfsStorage } from './src/data-providers/json-entity-opfs-storage.js';
 //export * from './src/data-api'; //reconsider if to make internal
 export { Controller, BackendMethod, ProgressListener, } from './src/server-action.js';
 export { Allow, Remult, withRemult, isBackend, EventSource, } from './src/context.js';
@@ -17,7 +18,7 @@ export { Sort } from './src/sort.js';
 export { CompoundIdField } from './src/CompoundIdField.js';
 export { Filter, } from './src/filter/filter-interfaces.js';
 export { UrlBuilder } from './urlBuilder.js';
-export { Validators } from './src/validators.js';
+export { Validators, valueValidator, createValidator, createValidatorWithArgs, createValueValidatorWithArgs, createValueValidator, } from './src/validators.js';
 export { ValueConverters } from './src/valueConverters.js';
 export { remult } from './src/remult-proxy.js';
 import { remult } from './src/remult-proxy.js';
@@ -36,6 +37,6 @@ export { SubscriptionChannel, } from './src/live-query/SubscriptionChannel.js';
  * await repo(Customer).insert()
  * ```
  */
-export function repo(entity) {
-    return remult.repo(entity);
+export function repo(entity, dataProvider) {
+    return remult.repo(entity, dataProvider);
 }

package/esm/remult-sql-js.js

@@ -0,0 +1,113 @@
+import { SqlDatabase } from './src/data-providers/sql-database.js';
+import { dbNamesOf, isDbReadonly, } from './src/filter/filter-consumer-bridge-to-sql-request.js';
+import { isAutoIncrement } from './src/remult3/RepositoryImplementation.js';
+export class SqlJsDataProvider {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    getLimitSqlSyntax(limit, offset) {
+        return ' limit ' + limit + ' offset ' + offset;
+    }
+    afterMutation;
+    createCommand() {
+        return new SqlJsCommand(this.db);
+    }
+    transaction(action) {
+        throw new Error('Method not implemented.');
+    }
+    async entityIsUsedForTheFirstTime(entity) {
+        await this.createTable(entity);
+    }
+    async ensureSchema(entities) {
+        for (const entity of entities) {
+            await this.createTable(entity);
+        }
+    }
+    async dropTable(entity) {
+        let e = await dbNamesOf(entity);
+        let sql = 'drop  table if exists ' + e.$entityName;
+        if (SqlDatabase.LogToConsole)
+            console.info(sql);
+        await this.createCommand().execute(sql);
+    }
+    addColumnSqlSyntax(x, dbName) {
+        let result = dbName;
+        const nullNumber = x.allowNull ? '' : ' default 0 not null';
+        if (x.valueType == Date)
+            result += ' integer';
+        else if (x.valueType == Boolean)
+            result += ' integer ' + nullNumber;
+        else if (x.valueType == Number) {
+            if (!x.valueConverter.fieldTypeInDb)
+                result += ' real ' + nullNumber;
+            else
+                result += ' ' + x.valueConverter.fieldTypeInDb + ' ' + nullNumber;
+        }
+        else
+            result += ' text' + (x.allowNull ? ' ' : " default '' not null ");
+        return result;
+    }
+    async createTable(entity) {
+        let result = '';
+        let e = await dbNamesOf(entity);
+        for (const x of entity.fields) {
+            if (!isDbReadonly(x, e) || isAutoIncrement(x)) {
+                if (result.length != 0)
+                    result += ',';
+                result += '\r\n  ';
+                if (isAutoIncrement(x)) {
+                    if (x.key != entity.idMetadata.field.key)
+                        throw 'in web sql, autoincrement is only allowed for primary key';
+                    result += e.$dbNameOf(x) + ' integer primary key autoincrement';
+                }
+                else {
+                    result += this.addColumnSqlSyntax(x, e.$dbNameOf(x));
+                    if (x.key == entity.idMetadata.field.key) {
+                        result += ' primary key';
+                    }
+                }
+            }
+        }
+        let sql = 'create table if not exists ' + e.$entityName + ' (' + result + '\r\n)';
+        if (SqlDatabase.LogToConsole)
+            console.log(sql);
+        await this.createCommand().execute(sql);
+    }
+    supportsJsonColumnType;
+    wrapIdentifier(name) {
+        return name;
+    }
+}
+class SqlJsCommand {
+    db;
+    values = {};
+    i = 0;
+    constructor(db) {
+        this.db = db;
+    }
+    async execute(sql) {
+        if (this.i == 0)
+            return new SqlJsSqlResult((await this.db).exec(sql));
+        return new SqlJsSqlResult((await this.db).exec(sql, this.values));
+    }
+    addParameterAndReturnSqlToken(val) {
+        if (val instanceof Date)
+            val = val.valueOf();
+        const key = ':' + ++this.i;
+        this.values[key] = val;
+        return key;
+    }
+}
+class SqlJsSqlResult {
+    result;
+    constructor(result) {
+        this.result = result;
+        this.rows =
+            result[0]?.values.map((row) => row.reduce((prev, curr, i) => ({ ...prev, [result[0].columns[i]]: curr }), {})) ?? [];
+    }
+    rows;
+    getColumnKeyInResultForIndexInSelect(index) {
+        return this.result[0]?.columns[index];
+    }
+}

package/esm/src/data-providers/array-entity-data-provider.js

@@ -157,7 +157,7 @@ export class ArrayEntityDataProvider {
         let j = this.translateToJson(data, names);
         let idf = this.entity.idMetadata.field;
         if (!(idf instanceof CompoundIdField)) {
-            if (idf.options.valueConverter?.fieldTypeInDb === 'autoincrement') {
+            if (idf.valueConverter.fieldTypeInDb === 'autoincrement') {
                 j[idf.key] = 1;
                 for (const row of this.rows) {
                     if (row[idf.key] >= j[idf.key])

package/esm/src/data-providers/json-data-provider.js

@@ -20,7 +20,7 @@ class JsonEntityDataProvider {
     }
     async loadEntityData(what) {
         let data = [];
-        let dbName = await this.entity.options.dbName;
+        let dbName = await this.entity.dbName;
         let s = await this.helper.getItem(dbName);
         if (s)
             data = JSON.parse(s);

package/esm/src/data-providers/json-entity-opfs-storage.js

@@ -0,0 +1,22 @@
+export class JsonEntityOpfsStorage {
+    //@internal
+    opfsRoot;
+    async getItem(entityDbName) {
+        if (!this.opfsRoot) {
+            this.opfsRoot = await navigator.storage.getDirectory();
+        }
+        const opfsFile = await this.opfsRoot.getFileHandle(entityDbName + '.json', {
+            create: true,
+        });
+        const readable = await opfsFile.getFile();
+        return await readable.text();
+    }
+    async setItem(entityDbName, json) {
+        const opfsFile = await this.opfsRoot.getFileHandle(entityDbName + '.json', {
+            create: true,
+        });
+        const writable = await opfsFile.createWritable();
+        await writable.write(json);
+        await writable.close();
+    }
+}

package/esm/src/data-providers/sql-database.js

@@ -324,6 +324,7 @@ class ActualSQLServerDataProvider {
         let { colKeys, select } = this.buildSelect(e);
         statement += ' returning ' + select;
         return r.execute(statement).then((sqlResult) => {
+            this.sql._getSourceSql().afterMutation?.();
             return this.buildResultRow(colKeys, sqlResult.rows[0], sqlResult);
         });
     }
@@ -334,7 +335,9 @@ class ActualSQLServerDataProvider {
         Filter.fromEntityFilter(this.entity, this.entity.idMetadata.getIdFilter(id)).__applyToConsumer(f);
         let statement = 'delete from ' + e.$entityName;
         statement += await f.resolveWhere();
-        return r.execute(statement).then(() => { });
+        return r.execute(statement).then(() => {
+            this.sql._getSourceSql().afterMutation?.();
+        });
     }
     async insert(data) {
         let e = await this.init();
@@ -362,9 +365,10 @@ class ActualSQLServerDataProvider {
         let statement = `insert into ${e.$entityName} (${cols}) values (${vals})`;
         let { colKeys, select } = this.buildSelect(e);
         statement += ' returning ' + select;
-        return await r
-            .execute(statement)
-            .then((sql) => this.buildResultRow(colKeys, sql.rows[0], sql));
+        return await r.execute(statement).then((sql) => {
+            this.sql._getSourceSql().afterMutation?.();
+            return this.buildResultRow(colKeys, sql.rows[0], sql);
+        });
     }
 }
 class myDummySQLCommand {
@@ -393,9 +397,9 @@ async function bulkInsert(array, db) {
         // do whatever
         const c = db.createCommand();
         let sql = 'insert into ' +
-            (await items[0]._.metadata.options.dbName) +
+            (await items[0]._.metadata.dbName) +
             ' (' +
-            (await Promise.all(items[0]._.metadata.fields.toArray().map((f) => f.options.dbName))).join(',') +
+            (await Promise.all(items[0]._.metadata.fields.toArray().map((f) => f.dbName))).join(',') +
             ') values ';
         sql += items
             .map((row) => '(' +

package/esm/src/filter/filter-consumer-bridge-to-sql-request.js

@@ -152,8 +152,7 @@ export class CustomSqlFilterBuilder {
 export function isDbReadonly(field, dbNames) {
     return (field.dbReadOnly ||
         field.isServerExpression ||
-        (field.options.sqlExpression &&
-            field.options.dbName != dbNames.$dbNameOf(field)));
+        (field.options.sqlExpression && field.dbName != dbNames.$dbNameOf(field)));
 }
 export async function dbNamesOf(repo, wrapIdentifier = (x) => x) {
     var meta = getEntityMetadata(repo);
@@ -182,7 +181,7 @@ export async function entityDbName(metadata, wrapIdentifier = (x) => x) {
             return await metadata.options.sqlExpression(metadata);
         }
     }
-    return wrapIdentifier(metadata.options.dbName);
+    return wrapIdentifier(metadata.dbName);
 }
 export async function fieldDbName(f, meta, wrapIdentifier = (x) => x) {
     try {
@@ -194,7 +193,7 @@ export async function fieldDbName(f, meta, wrapIdentifier = (x) => x) {
             else
                 result = f.options.sqlExpression;
             if (!result)
-                return f.options.dbName;
+                return f.dbName;
             return result;
         }
         const rel = getRelationInfo(f.options);
@@ -205,7 +204,7 @@ export async function fieldDbName(f, meta, wrapIdentifier = (x) => x) {
             if (fInfo)
                 return fieldDbName(fInfo, meta, wrapIdentifier);
         }
-        return wrapIdentifier(f.options.dbName);
+        return wrapIdentifier(f.dbName);
     }
     finally {
     }

package/esm/src/remult-proxy.js

@@ -120,6 +120,10 @@ export class RemultProxy {
                 .remultFactory()
                 .repo(...args)
                 .findFirst(...args2),
+            findOne: (...args2) => self
+                .remultFactory()
+                .repo(...args)
+                .findOne(...args2),
             findId: (a, b) => self
                 .remultFactory()
                 .repo(...args)

package/esm/src/remult3/Fields.js

@@ -3,6 +3,7 @@ import { v4 as uuid } from 'uuid';
 import { ValueConverters } from '../valueConverters.js';
 import { buildOptions, columnsOfType } from './RepositoryImplementation.js';
 import { relationInfoMember } from './relationInfoMember.js';
+import { Validators } from '../validators.js';
 export class Fields {
     /**
      * Stored as a JSON.stringify - to store as json use Fields.json
@@ -198,6 +199,12 @@ export function Field(valueType, ...options) {
         const key = typeof context === 'string' ? context : context.name.toString();
         let factory = (remult) => {
             let r = buildOptions(options, remult);
+            if (r.required) {
+                r.validate = addValidator(r.validate, Validators.required);
+            }
+            if (r.maxLength) {
+                r.validate = addValidator(r.validate, Validators.maxLength(r.maxLength));
+            }
             if (!r.valueType && valueType) {
                 r.valueType = valueType();
             }
@@ -241,3 +248,18 @@ export function checkTarget(target) {
     if (!target)
         throw new Error("Set the 'experimentalDecorators:true' option in your 'tsconfig' or 'jsconfig' (target undefined)");
 }
+function addValidator(validators, newValidator, atStart = false) {
+    if (!newValidator)
+        return;
+    const newValidators = Array.isArray(newValidator)
+        ? newValidator
+        : [newValidator];
+    const validatorsArray = Array.isArray(validators)
+        ? validators
+        : validators
+            ? [validators]
+            : [];
+    return atStart
+        ? [...newValidators, ...validatorsArray]
+        : [...validatorsArray, ...newValidators];
+}