remult 0.21.1 → 0.22.0

package/esm/src/remult3/remult3.d.ts

@@ -1,10 +1,10 @@
-import { ClassType } from "../../classType";
-import { FieldMetadata } from "../column-interfaces";
-import { LiveQueryChange, SubscriptionListener, Unsubscribe } from "../live-query/SubscriptionChannel";
-import { EntityOptions } from "../entity";
-import { SortSegment } from "../sort";
-import { entityEventListener } from "../__EntityValueProvider";
-import { ErrorInfo } from "../..";
+import { ClassType } from '../../classType';
+import { FieldMetadata } from '../column-interfaces';
+import { LiveQueryChange, SubscriptionListener, Unsubscribe } from '../live-query/SubscriptionChannel';
+import { EntityOptions } from '../entity';
+import { SortSegment } from '../sort';
+import { entityEventListener } from '../__EntityValueProvider';
+import { ErrorInfo } from '../..';
 export interface EntityRef<entityType> extends Subscribable {
     hasErrors(): boolean;
     undoChanges(): any;
@@ -44,7 +44,7 @@ export interface Subscribable {
 }
 export declare type FieldsRef<entityType> = {
     [Properties in keyof OmitEB<entityType>]: entityType[Properties] extends {
-        id?: (number | string);
+        id?: number | string;
     } ? IdFieldRef<entityType, entityType[Properties]> : FieldRef<entityType, entityType[Properties]>;
 } & {
     find(fieldMetadataOrKey: FieldMetadata | string): FieldRef<entityType, any>;
@@ -68,12 +68,12 @@ export interface IdFieldRef<entityType, valueType> extends FieldRef<entityType,
         id?: number;
     } ? number : valueType extends {
         id?: string;
-    } ? string : (string | number)): any;
-    getId(): (valueType extends {
+    } ? string : string | number): any;
+    getId(): valueType extends {
         id?: number;
     } ? number : valueType extends {
         id?: string;
-    } ? string : (string | number));
+    } ? string : string | number;
 }
 export interface FieldRef<entityType = any, valueType = any> extends Subscribable {
     error: string;
@@ -110,7 +110,7 @@ export interface EntityMetadata<entityType = any> {
     /** A human readable caption for the entity. Can be used to achieve a consistent caption for a field throughout the app
      * @example
      * <h1>Create a new item in {taskRepo.metadata.caption}</h1>
-    */
+     */
     readonly caption: string;
     /** The options send to the `Entity`'s decorator */
     readonly options: EntityOptions;
@@ -122,7 +122,7 @@ export interface EntityMetadata<entityType = any> {
      * if (taskRepo.metadata.apiUpdateAllowed(task)){
      *   // Allow user to edit the entity
      * }
-    */
+     */
     apiUpdateAllowed(item?: entityType): boolean;
     /** true if the current user is allowed to read from entity
      * @example
@@ -138,7 +138,7 @@ export interface EntityMetadata<entityType = any> {
      * if (taskRepo.metadata.apiDeleteAllowed(task)){
      *   // display delete button
      * }
-    */
+     */
     apiDeleteAllowed(item?: entityType): boolean;
     /** true if the current user is allowed to create an entity instance
      * @example
@@ -146,7 +146,7 @@ export interface EntityMetadata<entityType = any> {
      * if (taskRepo.metadata.apiInsertAllowed(task)){
      *   // display insert button
      * }
-    */
+     */
     apiInsertAllowed(item?: entityType): boolean;
     /** Returns the dbName - based on it's `dbName` option and it's `sqlExpression` option */
     getDbName(): Promise<string>;
@@ -158,7 +158,7 @@ export declare type idType<entityType> = entityType extends {
     id?: number;
 } ? number : entityType extends {
     id?: string;
-} ? string : (string | number);
+} ? string : string | number;
 /**used to perform CRUD operations on an `entityType` */
 export interface Repository<entityType> {
     /** returns a result array based on the provided options */
@@ -190,7 +190,7 @@ export interface Repository<entityType> {
      * @see [EntityFilter](http://remult.dev/docs/entityFilter.html)
      * @example
      * await taskRepo.count({ completed:false })
-    */
+     */
     count(where?: EntityFilter<entityType>): Promise<number>;
     /**Validates an item
      * @example
@@ -202,11 +202,11 @@ export interface Repository<entityType> {
      * // Can also be used to validate specific fields
      * const error = repo.validate(task,"title")
      */
-    validate(item: Partial<entityType>, ...fields: (Extract<keyof OmitEB<entityType>, string>)[]): Promise<ErrorInfo<entityType> | undefined>;
+    validate(item: Partial<entityType>, ...fields: Extract<keyof OmitEB<entityType>, string>[]): Promise<ErrorInfo<entityType> | undefined>;
     /** saves an item or item[] to the data source. It assumes that if an `id` value exists, it's an existing row - otherwise it's a new row
      * @example
      * await taskRepo.save({...task, completed:true })
-    */
+     */
     save(item: Partial<OmitEB<entityType>>[]): Promise<entityType[]>;
     save(item: Partial<OmitEB<entityType>>): Promise<entityType>;
     /**Insert an item or item[] to the data source
@@ -214,41 +214,46 @@ export interface Repository<entityType> {
      * await taskRepo.insert({title:"task a"})
      * @example
      * await taskRepo.insert([{title:"task a"}, {title:"task b", completed:true }])
-    */
+     */
     insert(item: Partial<OmitEB<entityType>>[]): Promise<entityType[]>;
     insert(item: Partial<OmitEB<entityType>>): Promise<entityType>;
     /** Updates an item, based on its `id`
      * @example
      * taskRepo.update(task.id,{...task,completed:true})
-    */
-    update(id: (entityType extends {
+     */
+    update(id: entityType extends {
         id?: number;
     } ? number : entityType extends {
         id?: string;
-    } ? string : (string | number)), item: Partial<OmitEB<entityType>>): Promise<entityType>;
+    } ? string : string | number, item: Partial<OmitEB<entityType>>): Promise<entityType>;
     update(id: Partial<OmitEB<entityType>>, item: Partial<OmitEB<entityType>>): Promise<entityType>;
     /** Deletes an Item*/
-    delete(id: (entityType extends {
+    delete(id: entityType extends {
         id?: number;
     } ? number : entityType extends {
         id?: string;
-    } ? string : (string | number))): Promise<void>;
+    } ? string : string | number): Promise<void>;
     delete(item: Partial<OmitEB<entityType>>): Promise<void>;
     /** Creates an instance of an item. It'll not be saved to the data source unless `save` or `insert` will be called for that item */
     create(item?: Partial<OmitEB<entityType>>): entityType;
+    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): Promise<entityType>;
+    fromJson(x: any[], isNew?: boolean): entityType[];
+    fromJson(x: 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
      * @example
      * console.log(repo.fields.title.caption) // displays the caption of a specific field
      * console.log(repo.fields.title.options)// writes the options that were defined for this field
-    */
+     */
     fields: FieldsMetadata<entityType>;
     /**The metadata for the `entity`
      * @See [EntityMetadata](https://remult.dev/docs/ref_entitymetadata.html)
-    */
+     */
     metadata: EntityMetadata<entityType>;
     addEventListener(listener: entityEventListener<entityType>): Unsubscribe;
 }
@@ -259,7 +264,7 @@ export interface LiveQuery<entityType> {
 export interface LiveQueryChangeInfo<entityType> {
     items: entityType[];
     changes: LiveQueryChange[];
-    applyChanges(prevState: entityType[]): entityType[];
+    applyChanges(prevState: entityType[] | undefined): 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
@@ -268,7 +273,7 @@ export interface FindOptions<entityType> extends FindOptionsBase<entityType> {
      *  limit:10,
      *  page:2
      * })
-    */
+     */
     limit?: number;
     /** Determines the page number that will be used to extract the data
      * @example
@@ -276,7 +281,7 @@ export interface FindOptions<entityType> extends FindOptionsBase<entityType> {
      *  limit:10,
      *  page:2
      * })
-    */
+     */
     page?: number;
 }
 /** Determines the order of items returned .
@@ -286,34 +291,34 @@ export interface FindOptions<entityType> extends FindOptionsBase<entityType> {
  * await this.remult.repo(Products).find({ orderBy: { price: "desc", name: "asc" }})
  */
 export declare type EntityOrderBy<entityType> = {
-    [Properties in keyof Partial<OmitEB<entityType>>]?: "asc" | "desc";
+    [Properties in keyof Partial<OmitEB<entityType>>]?: 'asc' | 'desc';
 };
 /**Used to filter the desired result set
  * @see [EntityFilter](http://remult.dev/docs/entityFilter.html)
  */
 export declare type EntityFilter<entityType> = {
-    [Properties in keyof Partial<OmitEB<entityType>>]?: (Partial<OmitEB<entityType>>[Properties] extends (number | Date | undefined) ? ComparisonValueFilter<Partial<OmitEB<entityType>>[Properties]> : Partial<OmitEB<entityType>>[Properties] extends (string | undefined) ? ContainsStringValueFilter & ComparisonValueFilter<string> : Partial<OmitEB<entityType>>[Properties] extends (boolean | undefined) ? ValueFilter<boolean> : Partial<OmitEB<entityType>>[Properties] extends ({
-        id?: (string | number);
-    } | undefined) ? IdFilter<Partial<OmitEB<entityType>>[Properties]> : ValueFilter<Partial<OmitEB<entityType>>[Properties]>) & ContainsStringValueFilter;
+    [Properties in keyof Partial<OmitEB<entityType>>]?: (Partial<OmitEB<entityType>>[Properties] extends number | Date | undefined ? ComparisonValueFilter<Partial<OmitEB<entityType>>[Properties]> : Partial<OmitEB<entityType>>[Properties] extends string | undefined ? ContainsStringValueFilter & ComparisonValueFilter<string> : Partial<OmitEB<entityType>>[Properties] extends boolean | undefined ? ValueFilter<boolean> : Partial<OmitEB<entityType>>[Properties] extends {
+        id?: string | number;
+    } | undefined ? IdFilter<Partial<OmitEB<entityType>>[Properties]> : ValueFilter<Partial<OmitEB<entityType>>[Properties]>) & ContainsStringValueFilter;
 } & {
     $or?: EntityFilter<entityType>[];
     $and?: EntityFilter<entityType>[];
 };
 export declare type ValueFilter<valueType> = valueType | valueType[] | {
     $ne?: valueType | valueType[];
-    "!="?: valueType | valueType[];
+    '!='?: valueType | valueType[];
     $in?: valueType[];
     $nin?: valueType[];
 };
 export declare type ComparisonValueFilter<valueType> = ValueFilter<valueType> & {
     $gt?: valueType;
-    ">"?: valueType;
+    '>'?: valueType;
     $gte?: valueType;
-    ">="?: valueType;
+    '>='?: valueType;
     $lt?: valueType;
-    "<"?: valueType;
+    '<'?: valueType;
     $lte?: valueType;
-    "<="?: valueType;
+    '<='?: valueType;
 };
 export interface ContainsStringValueFilter {
     $contains?: string;
@@ -328,24 +333,24 @@ export interface LoadOptions<entityType> {
 }
 export interface FindOptionsBase<entityType> extends LoadOptions<entityType> {
     /** filters the data
-    * @example
-    * await taskRepo.find({where: { completed:false }})
-    * @see For more usage examples see [EntityFilter](https://remult.dev/docs/entityFilter.html)
-    */
+     * @example
+     * await taskRepo.find({where: { completed:false }})
+     * @see For more usage examples see [EntityFilter](https://remult.dev/docs/entityFilter.html)
+     */
     where?: EntityFilter<entityType>;
     /** Determines the order of items returned .
-    * @example
-    * await this.remult.repo(Products).find({ orderBy: { name: "asc" }})
-    * @example
-    * await this.remult.repo(Products).find({ orderBy: { price: "desc", name: "asc" }})
-    */
+     * @example
+     * await this.remult.repo(Products).find({ orderBy: { name: "asc" }})
+     * @example
+     * await this.remult.repo(Products).find({ orderBy: { price: "desc", name: "asc" }})
+     */
     orderBy?: EntityOrderBy<entityType>;
 }
 export interface FindFirstOptions<entityType> extends FindOptionsBase<entityType>, FindFirstOptionsBase<entityType> {
 }
 export interface FindFirstOptionsBase<entityType> extends LoadOptions<entityType> {
     /** determines if to cache the result, and return the results from cache.
-      */
+     */
     useCache?: boolean;
     /** If set to true and an item is not found, it's created and returned*/
     createIfNotFound?: boolean;
@@ -366,7 +371,7 @@ export interface QueryResult<entityType> {
      * for await (const task of taskRepo.query()) {
      *   await taskRepo.save({ ...task, completed });
      * }
-    */
+     */
     [Symbol.asyncIterator](): {
         next: () => Promise<IteratorResult<entityType, entityType>>;
     };

package/esm/src/remult3/remult3.js

@@ -1,2 +1 @@
-;
 export {};

package/esm/src/server-action.d.ts

@@ -17,7 +17,7 @@ export declare abstract class Action<inParam, outParam> implements ActionInterfa
     run(pIn: inParam, baseUrl?: string, http?: RestDataProviderHttpProvider): Promise<outParam>;
     doWork: (args: any[], self: any, baseUrl?: string, http?: RestDataProviderHttpProvider) => Promise<any>;
     protected abstract execute(info: inParam, req: Remult, res: DataApiResponse): Promise<outParam>;
-    __register(reg: (url: string, queue: boolean, allowed: AllowedForInstance<any>, what: ((data: any, req: Remult, res: DataApiResponse) => void)) => void): void;
+    __register(reg: (url: string, queue: boolean, allowed: AllowedForInstance<any>, what: (data: any, req: Remult, res: DataApiResponse) => void) => void): void;
 }
 export declare class ForbiddenError extends Error {
     constructor();
@@ -26,7 +26,7 @@ export declare class ForbiddenError extends Error {
 export declare class myServerAction extends Action<inArgs, result> {
     private types;
     private options;
-    private originalMethod;
+    originalMethod: (args: any[]) => any;
     constructor(name: string, types: any[], options: BackendMethodOptions<any>, originalMethod: (args: any[]) => any);
     protected execute(info: inArgs, remult: Remult, res: DataApiResponse): Promise<result>;
 }
@@ -54,9 +54,16 @@ export declare const actionInfo: {
     };
 };
 export declare const serverActionField: unique symbol;
-export declare function Controller(key: string): (target: any) => any;
+export declare function Controller(key: string): (target: any, context?: any) => any;
+export interface ClassMethodDecoratorContextStub<This = unknown, Value extends (this: This, ...args: any) => any = (this: This, ...args: any) => any> {
+    readonly kind: 'method';
+    readonly name: string | symbol;
+    readonly access: {
+        has(object: This): boolean;
+    };
+}
 /** Indicates that the decorated methods runs on the backend. See: [Backend Methods](https://remult.dev/docs/backendMethods.html) */
-export declare function BackendMethod<type = any>(options: BackendMethodOptions<type>): (target: any, key: string, descriptor: any) => any;
+export declare function BackendMethod<type = any>(options: BackendMethodOptions<type>): (target: any, context: ClassMethodDecoratorContextStub<type> | string, descriptor?: any) => any;
 export interface jobWasQueuedResult {
     queuedJobId?: string;
 }
@@ -76,6 +83,6 @@ export declare function prepareReceivedArgs(types: any[], args: any[], remult: R
 export declare const classBackendMethodsArray: unique symbol;
 export interface ActionInterface {
     doWork: (args: any[], self: any, baseUrl?: string, http?: RestDataProviderHttpProvider) => Promise<any>;
-    __register(reg: (url: string, queue: boolean, allowed: AllowedForInstance<any>, what: ((data: any, req: Remult, res: DataApiResponse) => void)) => void): any;
+    __register(reg: (url: string, queue: boolean, allowed: AllowedForInstance<any>, what: (data: any, req: Remult, res: DataApiResponse) => void) => void): any;
 }
 export {};

package/esm/src/server-action.js

@@ -1,8 +1,8 @@
 import 'reflect-metadata';
-import { Remult, allEntities, classHelpers, ClassHelper, setControllerSettings, doTransaction } from './context';
-import { buildRestDataProvider } from "./buildRestDataProvider";
+import { Remult, allEntities, classHelpers, ClassHelper, setControllerSettings, doTransaction, isBackend, } from './context';
+import { buildRestDataProvider } from './buildRestDataProvider';
 import { SqlDatabase } from './data-providers/sql-database';
-import { getEntityRef, decorateColumnSettings, getEntitySettings, getControllerRef } from './remult3';
+import { getEntityRef, decorateColumnSettings, getEntitySettings, getControllerRef, checkTarget, } from './remult3';
 import { remult } from './remult-proxy';
 export class Action {
     constructor(actionUrl, queue, allowed) {
@@ -24,7 +24,7 @@ export class Action {
                 await actionInfo.runActionWithoutBlockingUI(async () => {
                     while (!runningJob || !runningJob.done) {
                         if (runningJob)
-                            await new Promise(res => setTimeout(() => {
+                            await new Promise((res) => setTimeout(() => {
                                 res(undefined);
                             }, 200));
                         runningJob = await http.post(baseUrl + '/' + Action.apiUrlForJobStatus, { queuedJobId: r.queuedJobId });
@@ -52,7 +52,8 @@ export class Action {
                 res.success(r);
             }
             catch (err) {
-                if (err.isForbiddenError) // got a problem in next with instance of ForbiddenError  - so replaced it with this bool
+                if (err.isForbiddenError)
+                    // got a problem in next with instance of ForbiddenError  - so replaced it with this bool
                     res.forbidden();
                 else
                     res.error(err);
@@ -63,7 +64,7 @@ export class Action {
 Action.apiUrlForJobStatus = 'jobStatusInQueue';
 export class ForbiddenError extends Error {
     constructor() {
-        super("Forbidden");
+        super('Forbidden');
         this.isForbiddenError = true;
     }
 }
@@ -94,16 +95,18 @@ export class myServerAction extends Action {
 export const actionInfo = {
     allActions: [],
     runningOnServer: false,
-    runActionWithoutBlockingUI: (what) => { return what(); },
+    runActionWithoutBlockingUI: (what) => {
+        return what();
+    },
     startBusyWithProgress: () => ({
         progress: (percent) => { },
-        close: () => { }
-    })
+        close: () => { },
+    }),
 };
 export const serverActionField = Symbol('serverActionField');
 const classOptions = new Map();
 export function Controller(key) {
-    return function (target) {
+    return function (target, context) {
         let r = target;
         classOptions.set(r, { key });
         setControllerSettings(target, { key });
@@ -112,14 +115,17 @@ export function Controller(key) {
 }
 /** Indicates that the decorated methods runs on the backend. See: [Backend Methods](https://remult.dev/docs/backendMethods.html) */
 export function BackendMethod(options) {
-    return (target, key, descriptor) => {
+    return (target, context, descriptor) => {
+        const key = typeof context === 'string' ? context : context.name.toString();
+        const originalMethod = descriptor ? descriptor.value : target;
+        let result = originalMethod;
+        checkTarget(target);
         if (target.prototype !== undefined) {
-            var originalMethod = descriptor.value;
-            var types = Reflect.getMetadata("design:paramtypes", target, key);
+            var types = Reflect.getMetadata('design:paramtypes', target, key);
             if (options.paramTypes)
                 types = options.paramTypes;
             // if types are undefined - you've forgot to set: "emitDecoratorMetadata":true
-            let serverAction = new myServerAction((options?.apiPrefix ? (options.apiPrefix + '/') : '') + key, types, options, args => originalMethod.apply(undefined, args));
+            let serverAction = new myServerAction((options?.apiPrefix ? options.apiPrefix + '/' : '') + key, types, options, (args) => originalMethod.apply(undefined, args));
             serverAction.doWork = async (args, self, url, http) => {
                 args = prepareArgsToSend(types, args);
                 if (options.blockUser === false) {
@@ -128,18 +134,23 @@ export function BackendMethod(options) {
                 else
                     return (await serverAction.run({ args }, url, http)).data;
             };
-            descriptor.value = async function (...args) {
-                if (!actionInfo.runningOnServer) {
+            result = async function (...args) {
+                if (!isBackend()) {
                     return await serverAction.doWork(args, undefined);
                 }
                 else
-                    return (await originalMethod.apply(undefined, args));
+                    return await originalMethod.apply(this, args);
             };
-            registerAction(target, descriptor);
-            descriptor.value[serverActionField] = serverAction;
-            return descriptor;
+            registerAction(target, result);
+            result[serverActionField] = serverAction;
+            if (descriptor) {
+                descriptor.value = result;
+                return descriptor;
+            }
+            else
+                return result;
         }
-        var types = Reflect.getMetadata("design:paramtypes", target, key);
+        var types = Reflect.getMetadata('design:paramtypes', target, key);
         if (options.paramTypes)
             types = options.paramTypes;
         let x = classHelpers.get(target.constructor);
@@ -147,7 +158,6 @@ export function BackendMethod(options) {
             x = new ClassHelper();
             classHelpers.set(target.constructor, x);
         }
-        var originalMethod = descriptor.value;
         let serverAction = {
             __register(reg) {
                 let c = new Remult();
@@ -156,8 +166,11 @@ export function BackendMethod(options) {
                     if (!controllerOptions.key) {
                         controllerOptions.key = c.repo(constructor).metadata.key;
                     }
-                    reg(controllerOptions.key + '/' + (options?.apiPrefix ? (options.apiPrefix + '/') : '') + key, options ? options.queue : false, options.allowed, async (d, req, res) => {
-                        d.args = d.args.map(x => isCustomUndefined(x) ? undefined : x);
+                    reg(controllerOptions.key +
+                        '/' +
+                        (options?.apiPrefix ? options.apiPrefix + '/' : '') +
+                        key, options ? options.queue : false, options.allowed, async (d, req, res) => {
+                        d.args = d.args.map((x) => (isCustomUndefined(x) ? undefined : x));
                         let allowed = options.allowed;
                         try {
                             let remult = req;
@@ -176,11 +189,11 @@ export function BackendMethod(options) {
                                         let rows = await repo.find({
                                             where: {
                                                 ...repo.metadata.idMetadata.getIdFilter(d.rowInfo.id),
-                                                $and: [repo.metadata.options.apiPrefilter]
-                                            }
+                                                $and: [repo.metadata.options.apiPrefilter],
+                                            },
                                         });
                                         if (rows.length != 1)
-                                            throw new Error("not found or too many matches");
+                                            throw new Error('not found or too many matches');
                                         y = rows[0];
                                         await repo.getEntityRef(y)._updateEntityBasedOnApi(d.rowInfo.data);
                                     }
@@ -195,8 +208,8 @@ export function BackendMethod(options) {
                                                 data: await defs.toApiJson(),
                                                 isNewRow: defs.isNew(),
                                                 wasChanged: defs.wasChanged(),
-                                                id: defs.getOriginalId()
-                                            }
+                                                id: defs.getOriginalId(),
+                                            },
                                         };
                                     }
                                     catch (err) {
@@ -213,7 +226,7 @@ export function BackendMethod(options) {
                                     try {
                                         r = {
                                             result: await originalMethod.apply(y, d.args),
-                                            fields: await controllerRef.toApiJson()
+                                            fields: await controllerRef.toApiJson(),
                                         };
                                     }
                                     catch (err) {
@@ -224,7 +237,8 @@ export function BackendMethod(options) {
                             res.success(r);
                         }
                         catch (err) {
-                            if (err.isForbiddenError) // got a problem in next with instance of ForbiddenError  - so replaced it with this bool
+                            if (err.isForbiddenError)
+                                // got a problem in next with instance of ForbiddenError  - so replaced it with this bool
                                 res.forbidden();
                             else
                                 res.error(err);
@@ -239,19 +253,22 @@ export function BackendMethod(options) {
                     await defs.__validateEntity();
                     let classOptions = x.classes.get(self.constructor);
                     if (!classOptions.key) {
-                        classOptions.key = defs.repository.metadata.key + "_methods";
+                        classOptions.key = defs.repository.metadata.key + '_methods';
                     }
                     try {
-                        let r = await (new class extends Action {
-                        }(classOptions.key + "/" + (options?.apiPrefix ? (options.apiPrefix + '/') : '') + key, options ? options.queue : false, options.allowed).run({
+                        let r = await new (class extends Action {
+                        })(classOptions.key +
+                            '/' +
+                            (options?.apiPrefix ? options.apiPrefix + '/' : '') +
+                            key, options ? options.queue : false, options.allowed).run({
                             args,
                             rowInfo: {
                                 data: await defs.toApiJson(),
                                 isNewRow: defs.isNew(),
                                 wasChanged: defs.wasChanged(),
-                                id: defs.getOriginalId()
-                            }
-                        }, baseUrl, http));
+                                id: defs.getOriginalId(),
+                            },
+                        }, baseUrl, http);
                         await defs._updateEntityBasedOnApi(r.rowInfo.data);
                         return r.result;
                     }
@@ -263,11 +280,14 @@ export function BackendMethod(options) {
                     let defs = getControllerRef(self, undefined);
                     try {
                         await defs.__validateEntity();
-                        let r = await (new class extends Action {
-                        }(x.classes.get(self.constructor).key + "/" + (options?.apiPrefix ? (options.apiPrefix + '/') : '') + key, options ? options.queue : false, options.allowed).run({
+                        let r = await new (class extends Action {
+                        })(x.classes.get(self.constructor).key +
+                            '/' +
+                            (options?.apiPrefix ? options.apiPrefix + '/' : '') +
+                            key, options ? options.queue : false, options.allowed).run({
                             args,
-                            fields: await defs.toApiJson()
-                        }, baseUrl, http));
+                            fields: await defs.toApiJson(),
+                        }, baseUrl, http);
                         await defs._updateEntityBasedOnApi(r.fields);
                         return r.result;
                     }
@@ -275,27 +295,33 @@ export function BackendMethod(options) {
                         throw defs.catchSaveErrors(e);
                     }
                 }
-            }
+            },
         };
-        descriptor.value = async function (...args) {
-            if (!actionInfo.runningOnServer) {
+        result = async function (...args) {
+            if (!isBackend()) {
                 let self = this;
                 return serverAction.doWork(args, self);
             }
             else
-                return (await originalMethod.apply(this, args));
+                return await originalMethod.apply(this, args);
         };
-        registerAction(target.constructor, descriptor);
-        descriptor.value[serverActionField] = serverAction;
-        return descriptor;
+        registerAction(target.constructor, result);
+        result[serverActionField] = serverAction;
+        if (descriptor) {
+            descriptor.value = result;
+            return descriptor;
+        }
+        else
+            return result;
     };
 }
 const customUndefined = {
-    _isUndefined: true
+    _isUndefined: true,
 };
-function registerAction(target, descriptor) {
-    (target[classBackendMethodsArray] || (target[classBackendMethodsArray] = [])).push(descriptor.value);
-    actionInfo.allActions.push(descriptor.value);
+function registerAction(target, resultMethod) {
+    ;
+    (target[classBackendMethodsArray] || (target[classBackendMethodsArray] = [])).push(resultMethod);
+    actionInfo.allActions.push(resultMethod);
 }
 function isCustomUndefined(x) {
     return x && x._isUndefined;
@@ -332,7 +358,7 @@ export function prepareArgsToSend(types, args) {
             }
         }
     }
-    return args.map(x => x !== undefined ? x : customUndefined);
+    return args.map((x) => (x !== undefined ? x : customUndefined));
 }
 export async function prepareReceivedArgs(types, args, remult, ds, res) {
     for (let index = 0; index < args.length; index++) {

package/esm/src/shared-tests/db-tests-setup.d.ts

@@ -1,9 +1,9 @@
-import { ClassType } from "../../classType";
-import { Remult } from "../context";
-import { DataProvider } from "../data-interfaces";
-import { Repository } from "../remult3";
-import { CategoriesForTesting } from "../tests/remult-3-entities";
-import { Status } from "../tests/testModel/models";
+import { ClassType } from '../../classType';
+import { Remult } from '../context';
+import { DataProvider } from '../data-interfaces';
+import { Repository } from '../remult3';
+import { CategoriesForTesting } from '../tests/remult-3-entities';
+import { Status } from '../tests/testModel/models';
 export declare function itWithFocus(key: string, what: () => Promise<void>, focus?: boolean): void;
 export declare function testAll(key: string, what: dbTestWhatSignature, focus?: boolean, options?: {
     exclude?: string[];
@@ -15,11 +15,11 @@ export declare const TestDbs: {
     mongo: string;
     inMemory: string;
 };
-export declare type dbTestWhatSignature = ((db: {
+export declare type dbTestWhatSignature = (db: {
     db: DataProvider;
     remult: Remult;
     createEntity<entityType>(entity: ClassType<entityType>): Promise<Repository<entityType>>;
-}) => Promise<void>);
+}) => Promise<void>;
 export declare type dbTestMethodSignature = ((key: string, what: dbTestWhatSignature, focus: boolean) => void) & {
     key?: string;
 };