remult 2.7.29 → 2.7.31

package/server/remult-admin.d.ts

@@ -3,6 +3,7 @@ import type { ClassType } from '../classType.js';
 import type { Remult } from '../src/context.js';
 import { EntityFilter } from '../src/remult3/remult3.js';
 export interface EntityUIInfo {
+    superKey: string;
     key: string;
     caption: string;
     fields: FieldUIInfo[];
@@ -12,6 +13,8 @@ export interface EntityUIInfo {
     color?: string;
 }
 export interface EntityRelationToManyInfo extends RelationFields {
+    key: string;
+    caption: string;
     entityKey: string;
     where?: any;
 }
@@ -35,13 +38,14 @@ export interface FieldRelationToOneInfo extends RelationFields {
     captionField: string;
     where?: any;
 }
-export interface AdminOptions extends DisplayOptions {
+export interface AdminEntitiesOptions {
     entities: ClassType<any>[];
     remult: Remult;
 }
-export interface DisplayOptions {
-    baseUrl?: string;
+export interface AdminDisplayOptions {
+    rootPath: string;
+    head: string;
 }
-export default function remultAdminHtml(options: AdminOptions): string;
-export declare function buildEntityInfo(options: AdminOptions): EntityUIInfo[];
+export default function remultAdminHtml(options: AdminDisplayOptions): string;
+export declare function buildEntityInfo(options: AdminEntitiesOptions): EntityUIInfo[];
 export type RelationsToOneValues = Record<string, Map<any, any>>;

package/server/remult-admin.js

@@ -8,122 +8,136 @@ var filter_interfaces_js_1 = require("../src/filter/filter-interfaces.js");
 var get_remult_admin_html_js_1 = require("./get-remult-admin-html.js");
 var RepositoryImplementation_js_1 = require("../src/remult3/RepositoryImplementation.js");
 function remultAdminHtml(options) {
-    var _a = tslib_1.__assign({}, options), remult = _a.remult, entities = _a.entities, optionsFromServer = tslib_1.__rest(_a, ["remult", "entities"]);
-    return (0, get_remult_admin_html_js_1.getHtml)().replace('<!--PLACE_HERE-->', "<script>\n  const optionsFromServer = ".concat(JSON.stringify(optionsFromServer), "\n</script>"));
+    var rootPath = options.rootPath, head = options.head;
+    return (0, get_remult_admin_html_js_1.getHtml)()
+        .replace('<!--PLACE_HERE_HEAD-->', head)
+        .replace('<!--PLACE_HERE_BODY-->', "<script>\n  window.optionsFromServer = ".concat(JSON.stringify({ rootPath: rootPath }), "\n</script>"));
 }
 function buildEntityInfo(options) {
-    var e_1, _a, e_2, _b, e_3, _c;
-    var _d, _e;
+    var e_1, _a;
+    var _b, _c;
     var entities = [];
-    try {
-        for (var _f = tslib_1.__values(options.entities.map(function (e) { return options.remult.repo(e).metadata; })), _g = _f.next(); !_g.done; _g = _f.next()) {
-            var metadata = _g.value;
-            var fields = [];
-            var relations = [];
-            var ids = {};
-            try {
-                for (var _h = (e_2 = void 0, tslib_1.__values(metadata.idMetadata.fields)), _j = _h.next(); !_j.done; _j = _h.next()) {
-                    var f = _j.value;
-                    ids[f.key] = true;
-                }
+    var _loop_1 = function (metadata) {
+        var e_2, _f, e_3, _g;
+        var fields = [];
+        var relations = [];
+        var ids = {};
+        try {
+            for (var _h = (e_2 = void 0, tslib_1.__values(metadata.idMetadata.fields)), _j = _h.next(); !_j.done; _j = _h.next()) {
+                var f = _j.value;
+                ids[f.key] = true;
             }
-            catch (e_2_1) { e_2 = { error: e_2_1 }; }
-            finally {
-                try {
-                    if (_j && !_j.done && (_b = _h.return)) _b.call(_h);
-                }
-                finally { if (e_2) throw e_2.error; }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (_j && !_j.done && (_f = _h.return)) _f.call(_h);
             }
-            var _loop_1 = function (x) {
-                if (!x.includedInApi(undefined))
-                    return "continue";
-                try {
-                    var relation = void 0;
-                    var valFieldKey = x.key;
-                    var info = (0, relationInfoMember_js_1.getRelationFieldInfo)(x);
-                    if (info) {
-                        var relInfo = info.getFields();
-                        var relRepo = options.remult.repo(info.toEntity);
-                        var where = typeof info.options.findOptions === 'object' &&
-                            info.options.findOptions.where
-                            ? filter_interfaces_js_1.Filter.entityFilterToJson(relRepo.metadata, info.options.findOptions.where)
-                            : undefined;
-                        var idField_1 = relRepo.metadata.idMetadata.field.key;
-                        if (info.type === 'reference' || info.type === 'toOne') {
-                            if (info.type == 'toOne') {
-                                for (var key in relInfo.fields) {
-                                    if (Object.prototype.hasOwnProperty.call(relInfo.fields, key)) {
-                                        var element = relInfo.fields[key];
-                                        valFieldKey = element;
-                                    }
+            finally { if (e_2) throw e_2.error; }
+        }
+        var _loop_2 = function (x) {
+            if (!x.includedInApi(undefined))
+                return "continue";
+            try {
+                var relation = void 0;
+                var valFieldKey = x.key;
+                var info = (0, relationInfoMember_js_1.getRelationFieldInfo)(x);
+                if (info) {
+                    var relInfo = info.getFields();
+                    var relRepo = options.remult.repo(info.toEntity);
+                    var where = typeof info.options.findOptions === 'object' &&
+                        info.options.findOptions.where
+                        ? filter_interfaces_js_1.Filter.entityFilterToJson(relRepo.metadata, info.options.findOptions.where)
+                        : undefined;
+                    var idField_1 = relRepo.metadata.idMetadata.field.key;
+                    if (info.type === 'reference' || info.type === 'toOne') {
+                        if (info.type == 'toOne') {
+                            for (var key in relInfo.fields) {
+                                if (Object.prototype.hasOwnProperty.call(relInfo.fields, key)) {
+                                    var element = relInfo.fields[key];
+                                    valFieldKey = element;
                                 }
                             }
-                            if (relRepo.metadata.apiReadAllowed) {
-                                relation = tslib_1.__assign(tslib_1.__assign({}, relInfo), { where: where, entityKey: relRepo.metadata.key, idField: idField_1, captionField: (_d = relRepo.metadata.fields
-                                        .toArray()
-                                        .find(function (x) { return x.key != idField_1 && x.valueType == String; })) === null || _d === void 0 ? void 0 : _d.key });
-                            }
                         }
-                        else if (info.type === 'toMany') {
-                            if (relRepo.metadata.apiReadAllowed) {
-                                relations.push(tslib_1.__assign(tslib_1.__assign({}, relInfo), { where: where, entityKey: relRepo.metadata.key }));
-                            }
-                            return "continue";
+                        if (relRepo.metadata.apiReadAllowed) {
+                            relation = tslib_1.__assign(tslib_1.__assign({}, relInfo), { where: where, entityKey: relRepo.metadata.key, idField: idField_1, captionField: (_b = relRepo.metadata.fields
+                                    .toArray()
+                                    .find(function (x) { return x.key != idField_1 && x.valueType == String; })) === null || _b === void 0 ? void 0 : _b.key });
                         }
                     }
-                    fields.push({
-                        key: x.key,
-                        readOnly: !x.apiUpdateAllowed(),
-                        values: (0, RepositoryImplementation_js_1.getValueList)(x),
-                        valFieldKey: valFieldKey,
-                        caption: x.caption,
-                        relationToOne: relation,
-                        inputType: x.inputType,
-                        type: x.valueConverter.fieldTypeInDb == 'json'
-                            ? 'json'
-                            : x.valueType === Number
-                                ? 'number'
-                                : x.valueType === Boolean
-                                    ? 'boolean'
-                                    : x.valueType === Date
-                                        ? 'date'
-                                        : 'string',
-                    });
-                }
-                catch (error) {
-                    console.error("[remult-admin] Error with ".concat(metadata.key, ".").concat(x.key, " field."));
-                    console.error("[remult-admin]", error);
-                }
-            };
-            try {
-                for (var _k = (e_3 = void 0, tslib_1.__values(metadata.fields.toArray())), _l = _k.next(); !_l.done; _l = _k.next()) {
-                    var x = _l.value;
-                    _loop_1(x);
+                    else if (info.type === 'toMany') {
+                        if (relRepo.metadata.apiReadAllowed) {
+                            relations.push(tslib_1.__assign(tslib_1.__assign({}, relInfo), { where: where, entityKey: relRepo.metadata.key, key: x.key, caption: x.caption }));
+                        }
+                        return "continue";
+                    }
                 }
+                fields.push({
+                    key: x.key,
+                    readOnly: !x.apiUpdateAllowed(),
+                    values: (0, RepositoryImplementation_js_1.getValueList)(x),
+                    valFieldKey: valFieldKey,
+                    caption: x.caption,
+                    relationToOne: relation,
+                    inputType: x.inputType,
+                    type: x.valueConverter.fieldTypeInDb == 'json'
+                        ? 'json'
+                        : x.valueType === Number
+                            ? 'number'
+                            : x.valueType === Boolean
+                                ? 'boolean'
+                                : x.valueType === Date
+                                    ? 'date'
+                                    : 'string',
+                });
             }
-            catch (e_3_1) { e_3 = { error: e_3_1 }; }
-            finally {
-                try {
-                    if (_l && !_l.done && (_c = _k.return)) _c.call(_k);
-                }
-                finally { if (e_3) throw e_3.error; }
+            catch (error) {
+                console.error("[remult-admin] Error with ".concat(metadata.key, ".").concat(x.key, " field."));
+                console.error("[remult-admin]", error);
             }
-            if (metadata.apiReadAllowed) {
-                entities.push({
-                    key: metadata.key,
-                    caption: metadata.caption,
-                    ids: ids,
-                    fields: fields,
-                    relations: relations,
-                    defaultOrderBy: (_e = metadata.options.defaultOrderBy) !== null && _e !== void 0 ? _e : { id: 'asc' },
-                });
+        };
+        try {
+            for (var _k = (e_3 = void 0, tslib_1.__values(metadata.fields.toArray())), _l = _k.next(); !_l.done; _l = _k.next()) {
+                var x = _l.value;
+                _loop_2(x);
             }
         }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (_l && !_l.done && (_g = _k.return)) _g.call(_k);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+        if (metadata.apiReadAllowed) {
+            var superKey = metadata.key;
+            var caption = metadata.caption;
+            var nbOfEntities = entities.filter(function (e) { return e.key === metadata.key; }).length;
+            if (nbOfEntities > 0) {
+                superKey = metadata.key + '_ext_' + nbOfEntities;
+                caption = metadata.caption + '*'.repeat(nbOfEntities);
+            }
+            entities.push({
+                superKey: superKey,
+                key: metadata.key,
+                caption: caption,
+                ids: ids,
+                fields: fields,
+                relations: relations,
+                defaultOrderBy: (_c = metadata.options.defaultOrderBy) !== null && _c !== void 0 ? _c : { id: 'asc' },
+            });
+        }
+    };
+    try {
+        for (var _d = tslib_1.__values(options.entities.map(function (e) { return options.remult.repo(e).metadata; })), _e = _d.next(); !_e.done; _e = _d.next()) {
+            var metadata = _e.value;
+            _loop_1(metadata);
+        }
     }
     catch (e_1_1) { e_1 = { error: e_1_1 }; }
     finally {
         try {
-            if (_g && !_g.done && (_a = _f.return)) _a.call(_f);
+            if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
         }
         finally { if (e_1) throw e_1.error; }
     }

package/server/remult-api-server.d.ts

@@ -52,10 +52,13 @@ export interface RemultServerOptions<RequestType> {
      * @example
      * admin: true
      * @example
-     * admin: ()=> remult.isAllowed('admin')
+     * admin: () => remult.isAllowed('admin')
      * @see [allowed](http://remult.dev/docs/allowed.html)
      */
-    admin?: Allowed;
+    admin?: Allowed | {
+        allow: Allowed;
+        customHtmlHead?: (remult: Remult) => string;
+    };
     /** Storage to use for backend methods that use queue */
     queueStorage?: QueueStorage;
     /**

package/server/remult-api-server.js

@@ -364,9 +364,13 @@ var RemultServerImplementation = /** @class */ (function () {
             if (this.options.admin !== undefined && this.options.admin !== false) {
                 var admin = function () {
                     return _this.process(function (remult, req, res, orig, origResponse) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                        var _a, _b;
-                        return tslib_1.__generator(this, function (_c) {
-                            if (remult.isAllowed(this.options.admin)) {
+                        var allowed, head;
+                        var _a, _b, _c;
+                        return tslib_1.__generator(this, function (_d) {
+                            allowed = (0, isOfType_js_1.isOfType)(this.options.admin, 'allow')
+                                ? this.options.admin.allow
+                                : this.options.admin;
+                            if (remult.isAllowed(allowed)) {
                                 if (((_a = orig === null || orig === void 0 ? void 0 : orig.params) === null || _a === void 0 ? void 0 : _a.id) === '__entities-metadata') {
                                     res.success((0, remult_admin_js_1.buildEntityInfo)({
                                         remult: remult,
@@ -374,10 +378,14 @@ var RemultServerImplementation = /** @class */ (function () {
                                     }));
                                 }
                                 else {
+                                    head = '<title>Admin</title>';
+                                    if ((0, isOfType_js_1.isOfType)(this.options.admin, 'allow') &&
+                                        this.options.admin.customHtmlHead) {
+                                        head = this.options.admin.customHtmlHead(remult);
+                                    }
                                     origResponse.send((0, remult_admin_js_1.default)({
-                                        remult: remult,
-                                        entities: this.options.entities,
-                                        baseUrl: this.options.rootPath + '/admin',
+                                        rootPath: (_c = this.options.rootPath) !== null && _c !== void 0 ? _c : '/api',
+                                        head: head,
                                     }));
                                 }
                             }

package/src/column-interfaces.d.ts

@@ -29,6 +29,8 @@ export interface FieldOptions<entityType = unknown, valueType = unknown> {
     /**
      * Determines whether this field can be updated via the API. This setting can also
      * be controlled based on user roles or other access control checks.
+     *
+     * _It happens after entity level authorization AND if it's allowed._
      * @example
      * // Prevent API from updating this field
      * @Fields.string({ allowApiUpdate: false })
@@ -122,8 +124,7 @@ export interface FieldOptions<entityType = unknown, valueType = unknown> {
 export interface FieldMetadata<valueType = unknown, entityType = unknown> {
     /** The field's member name in an object.
      * @example
-     * const taskRepo = remult.repo(Task);
-     * console.log(taskRepo.metadata.fields.title.key);
+     * console.log(repo(Task).metadata.fields.title.key);
      * // result: title
      */
     readonly key: entityType extends object ? keyof entityType & string : string;
@@ -154,8 +155,7 @@ export interface FieldMetadata<valueType = unknown, entityType = unknown> {
     readonly allowNull: boolean;
     /** The class that contains this field
      * @example
-     * const taskRepo = remult.repo(Task);
-     * Task == taskRepo.metadata.fields.title.target //will return true
+     * Task == repo(Task).metadata.fields.title.target //will return true
      */
     readonly target: ClassType<valueType>;
     /**
@@ -179,9 +179,8 @@ export interface FieldMetadata<valueType = unknown, entityType = unknown> {
    * Determines if the current user is allowed to update a specific entity instance.
    
    * @example
-   * const taskRepo = remult.repo(Task);
    * // Check if the current user is allowed to update a specific task
-   * if (taskRepo.metadata.apiUpdateAllowed(task)){
+   * if (repo(Task).metadata.apiUpdateAllowed(task)){
    *   // Allow user to edit the entity
    * }
    * @see {@link FieldOptions#allowApiUpdate} for configuration details

package/src/filter/filter-interfaces.js

@@ -936,8 +936,13 @@ function buildFilterFromRequestParameters(entity, filterInfo) {
             }
             finally { if (e_5) throw e_5.error; }
         }
-        if (not.length == 1 && !where.$not) {
-            where = not[0];
+        if (not.length == 1) {
+            if (!where.$not) {
+                where.$not = not[0].$not;
+            }
+            else {
+                where.$not.push(not[0].$not);
+            }
         }
         else {
             addAnd({

package/src/remult3/remult3.d.ts

@@ -212,8 +212,7 @@ export interface EntityMetadata<entityType = unknown> {
     /** true if the current user is allowed to update an entity instance
      * @see {@link EntityOptions.allowApiUpdate
      * @example
-     * const taskRepo = remult.repo(Task);
-     * if (taskRepo.metadata.apiUpdateAllowed(task)){
+     * if (repo(Task).metadata.apiUpdateAllowed(task)){
      *   // Allow user to edit the entity
      * }
      */
@@ -221,8 +220,7 @@ export interface EntityMetadata<entityType = unknown> {
     /** true if the current user is allowed to read from entity
      * @see {@link EntityOptions.allowApiRead}
      * @example
-     * const taskRepo = remult.repo(Task);
-     * if (taskRepo.metadata.apiReadAllowed){
+     * if (repo(Task).metadata.apiReadAllowed){
      *   await taskRepo.find()
      * }
      */
@@ -230,8 +228,7 @@ export interface EntityMetadata<entityType = unknown> {
     /** true if the current user is allowed to delete an entity instance
      * * @see {@link EntityOptions.allowApiDelete}
      * @example
-     * const taskRepo = remult.repo(Task);
-     * if (taskRepo.metadata.apiDeleteAllowed(task)){
+     * if (repo(Task).metadata.apiDeleteAllowed(task)){
      *   // display delete button
      * }
      */
@@ -239,8 +236,7 @@ export interface EntityMetadata<entityType = unknown> {
     /** true if the current user is allowed to create an entity instance
      * @see {@link EntityOptions.allowApiInsert}
      * @example
-     * const taskRepo = remult.repo(Task);
-     * if (taskRepo.metadata.apiInsertAllowed(task)){
+     * if (repo(Task).metadata.apiInsertAllowed(task)){
      *   // display insert button
      * }
      */
@@ -389,7 +385,7 @@ export type GroupByResult<entityType, groupByFields extends (keyof entityType)[]
 } & {
     $count: number;
 };
-/**used to perform CRUD operations on an `entityType` */
+/** used to perform CRUD operations on an `entityType` */
 export interface Repository<entityType> {
     /** returns a result array based on the provided options */
     find(options?: FindOptions<entityType>): Promise<entityType[]>;
@@ -611,13 +607,36 @@ export interface Repository<entityType> {
      *
      */
     create(item?: Partial<MembersOnly<entityType>>): entityType;
+    /**
+     * Translates an entity to a json object.
+     * - Ready to be sent to the client _(Date & co are managed)_
+     * - Strip out fields that are not allowed to be sent to the client! Check: [Field.includeInApi](http://remult.dev/docs/ref_field#includeinapi)
+     *
+     * @example
+     * ```ts
+     * const tasks = repo(Task).toJson(repo(Task).find())
+     * ```
+     *
+     * @param item Can be an array or a single entity, awaitable or not
+     */
     toJson(item: Promise<entityType[]>): Promise<any[]>;
     toJson(item: entityType[]): any[];
     toJson(item: Promise<entityType>): Promise<any>;
     toJson(item: entityType): any;
-    /** Translates a json object to an item instance */
-    fromJson(x: any[], isNew?: boolean): entityType[];
-    fromJson(x: any, isNew?: boolean): entityType;
+    /**
+     * Translates a json object to an item instance.
+     *
+     * @example
+     * ```ts
+     * const data = // from the server
+     * const tasks = repo(Task).fromJson(data)
+     * ```
+     *
+     * @param data Can be an array or a single element
+     * @param isNew To help the creation of the instance
+     */
+    fromJson(data: any[], isNew?: boolean): entityType[];
+    fromJson(data: any, isNew?: boolean): entityType;
     /** returns an `entityRef` for an item returned by `create`, `find` etc... */
     getEntityRef(item: entityType): EntityRef<entityType>;
     /** Provides information about the fields of the Repository's entity
@@ -709,26 +728,26 @@ export interface LiveQueryChangeInfo<entityType> {
 export interface FindOptions<entityType> extends FindOptionsBase<entityType> {
     /** Determines the number of rows returned by the request, on the browser the default is 100 rows
      * @example
-     * await this.remult.repo(Products).find({
-     *  limit:10,
-     *  page:2
+     * await repo(Products).find({
+     *   limit: 10,
+     *   page: 2
      * })
      */
     limit?: number;
     /** Determines the page number that will be used to extract the data
      * @example
-     * await this.remult.repo(Products).find({
-     *  limit:10,
-     *  page:2
+     * await repo(Products).find({
+     *   limit: 10,
+     *  page: 2
      * })
      */
     page?: number;
 }
 /** Determines the order of items returned .
  * @example
- * await this.remult.repo(Products).find({ orderBy: { name: "asc" }})
+ * await repo(Products).find({ orderBy: { name: "asc" }})
  * @example
- * await this.remult.repo(Products).find({ orderBy: { price: "desc", name: "asc" }})
+ * await repo(Products).find({ orderBy: { price: "desc", name: "asc" }})
  */
 export declare type EntityOrderBy<entityType> = {
     [Properties in keyof Partial<MembersOnly<entityType>>]?: 'asc' | 'desc';
@@ -985,13 +1004,13 @@ export interface LoadOptions<entityType> {
      * Example usage:
      * ```
      * // Deprecated usage with 'load' option
-     * await remult.repo(Order).find({
+     * await repo(Order).find({
      *   load: (o) => [o.customer],
      * });
      *
      *
      * // Preferred usage with 'Relations.toOne' and 'include' option
-     * await remult.repo(Order).find({
+     * await repo(Order).find({
      *   include: { customer: true },
      * });
      * ```
@@ -1029,9 +1048,9 @@ export interface FindOptionsBase<entityType> extends LoadOptions<entityType> {
     where?: EntityFilter<entityType>;
     /** Determines the order of items returned .
      * @example
-     * await this.remult.repo(Products).find({ orderBy: { name: "asc" }})
+     * await repo(Products).find({ orderBy: { name: "asc" }})
      * @example
-     * await this.remult.repo(Products).find({ orderBy: { price: "desc", name: "asc" }})
+     * await repo(Products).find({ orderBy: { price: "desc", name: "asc" }})
      */
     orderBy?: EntityOrderBy<entityType>;
 }

package/src/valueConverters.js

@@ -138,7 +138,9 @@ var ValueConverters = /** @class */ (function () {
         toJson: function (value) { return ValueConverters.Number.toDb(value); },
         fromInput: function (x, type) {
             var r = +x;
-            if (x === null || x === undefined)
+            if (x === null)
+                return null;
+            if (x === undefined)
                 return undefined;
             return r;
         },