remult 2.7.28 → 2.7.30

package/server/remult-admin.d.ts

@@ -12,6 +12,8 @@ export interface EntityUIInfo {
     color?: string;
 }
 export interface EntityRelationToManyInfo extends RelationFields {
+    key: string;
+    caption: string;
     entityKey: string;
     where?: any;
 }
@@ -35,13 +37,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,8 +8,10 @@ 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;
@@ -37,57 +39,63 @@ function buildEntityInfo(options) {
             var _loop_1 = function (x) {
                 if (!x.includedInApi(undefined))
                     return "continue";
-                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;
+                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 });
+                            }
                         }
-                        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 }));
+                        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";
                         }
-                        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 (error) {
+                    console.error("[remult-admin] Error with ".concat(metadata.key, ".").concat(x.key, " field."));
+                    console.error("[remult-admin]", error);
                 }
-                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',
-                });
             };
             try {
                 for (var _k = (e_3 = void 0, tslib_1.__values(metadata.fields.toArray())), _l = _k.next(); !_l.done; _l = _k.next()) {

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/getEntityRef.js

@@ -16,6 +16,8 @@ exports.getEntityKey = getEntityKey;
 function getEntityRef(entity, throwException) {
     var _a;
     if (throwException === void 0) { throwException = true; }
+    if (entity === undefined)
+        throw new Error('entity is undefined');
     var x = entity[exports.entityMember];
     if (!x && throwException)
         throw new Error('item ' +

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>;
 }