remult 0.25.5-exp.2 → 0.25.5-exp.21

package/server/remult-admin.d.ts

@@ -0,0 +1,36 @@
+import { type RelationFields } from '../src/remult3/relationInfoMember.js';
+import type { ClassType } from '../classType.js';
+import type { Remult } from '../src/context.js';
+export interface EntityUIInfo {
+    key: string;
+    caption: string;
+    fields: FieldUIInfo[];
+    ids: Record<string, true>;
+    relations: EntityRelationToManyInfo[];
+}
+export interface EntityRelationToManyInfo extends RelationFields {
+    entityKey: string;
+    where?: any;
+}
+export interface FieldUIInfo {
+    key: string;
+    valFieldKey: string;
+    caption: string;
+    type: 'json' | 'string' | 'number' | 'boolean';
+    relationToOne?: FieldRelationToOneInfo;
+}
+export interface FieldRelationToOneInfo extends RelationFields {
+    entityKey: string;
+    idField: string;
+    captionField: string;
+    where?: any;
+}
+export interface AdminOptions extends DisplayOptions {
+    entities: ClassType<any>[];
+    remult: Remult;
+}
+export interface DisplayOptions {
+    baseUrl?: string;
+}
+export default function remultAdminHtml(options: AdminOptions): string;
+export declare function buildEntityInfo(options: AdminOptions): EntityUIInfo[];

package/server/remult-admin.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildEntityInfo = void 0;
+var tslib_1 = require("tslib");
+var CompoundIdField_js_1 = require("../src/CompoundIdField.js");
+var relationInfoMember_js_1 = require("../src/remult3/relationInfoMember.js");
+var filter_interfaces_js_1 = require("../src/filter/filter-interfaces.js");
+var get_remult_admin_html_js_1 = require("./get-remult-admin-html.js");
+function remultAdminHtml(options) {
+    var optionsFromServer = tslib_1.__assign({}, options);
+    //@ts-ignore
+    delete optionsFromServer.entities;
+    delete optionsFromServer.remult;
+    return (0, get_remult_admin_html_js_1.getHtml)().replace('<!--PLACE_HERE-->', "<script >const entities = ".concat(JSON.stringify(buildEntityInfo(options)), "\n    const optionsFromServer = ").concat(JSON.stringify(optionsFromServer), "\n    </script>"));
+}
+exports.default = remultAdminHtml;
+function buildEntityInfo(options) {
+    var e_1, _a, e_2, _b, e_3, _c;
+    var _d;
+    var entities = [];
+    try {
+        for (var _e = tslib_1.__values(options.entities.map(function (e) { return options.remult.repo(e).metadata; })), _f = _e.next(); !_f.done; _f = _e.next()) {
+            var metadata = _f.value;
+            var fields = [];
+            var relations = [];
+            var ids = {};
+            if (metadata.idMetadata.field instanceof CompoundIdField_js_1.CompoundIdField) {
+                try {
+                    for (var _g = (e_2 = void 0, tslib_1.__values(metadata.idMetadata.field.fields)), _h = _g.next(); !_h.done; _h = _g.next()) {
+                        var field = _h.value;
+                        ids[field.key] = true;
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (_h && !_h.done && (_b = _g.return)) _b.call(_g);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+            }
+            else
+                ids[metadata.idMetadata.field.key] = true;
+            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;
+                                }
+                            }
+                        }
+                        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') {
+                        relations.push(tslib_1.__assign(tslib_1.__assign({}, relInfo), { where: where, entityKey: relRepo.metadata.key }));
+                        return "continue";
+                    }
+                }
+                fields.push({
+                    key: x.key,
+                    valFieldKey: valFieldKey,
+                    caption: x.caption,
+                    relationToOne: relation,
+                    type: x.valueConverter.fieldTypeInDb == 'json'
+                        ? 'json'
+                        : x.valueType === Number
+                            ? 'number'
+                            : x.valueType === Boolean
+                                ? 'boolean'
+                                : 'string',
+                });
+            };
+            try {
+                for (var _j = (e_3 = void 0, tslib_1.__values(metadata.fields.toArray())), _k = _j.next(); !_k.done; _k = _j.next()) {
+                    var x = _k.value;
+                    _loop_1(x);
+                }
+            }
+            catch (e_3_1) { e_3 = { error: e_3_1 }; }
+            finally {
+                try {
+                    if (_k && !_k.done && (_c = _j.return)) _c.call(_j);
+                }
+                finally { if (e_3) throw e_3.error; }
+            }
+            entities.push({
+                key: metadata.key,
+                caption: metadata.caption,
+                ids: ids,
+                fields: fields,
+                relations: relations,
+            });
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_f && !_f.done && (_a = _e.return)) _a.call(_e);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return entities;
+}
+exports.buildEntityInfo = buildEntityInfo;

package/src/remult-static.js

@@ -22,7 +22,8 @@ var x = {
     },
     captionTransformer: undefined,
 };
-if (process.env['IGNORE_GLOBAL_REMULT_IN_TESTS'] ||
+if ((typeof process !== 'undefined' &&
+    process.env['IGNORE_GLOBAL_REMULT_IN_TESTS']) ||
     typeof globalThis[remultStaticKey] === 'undefined') {
     globalThis[remultStaticKey] = x;
 }

package/src/remult3/Fields.d.ts

@@ -129,5 +129,6 @@ export declare class Relations {
 export declare function Field<entityType = any, valueType = any>(valueType: (() => valueType extends number ? Number : valueType extends string ? String : valueType extends boolean ? Boolean : ClassType<valueType>) | undefined, ...options: (FieldOptions<entityType, valueType> | ((options: FieldOptions<entityType, valueType>, remult: Remult) => void))[]): (target: any, context: ClassFieldDecoratorContextStub<entityType, valueType | undefined> | string, c?: any) => void;
 export interface StringFieldOptions<entityType = any> extends FieldOptions<entityType, string> {
     maxLength?: number;
+    minLength?: number;
 }
 export declare function checkTarget(target: any): void;

package/src/remult3/Fields.js

@@ -254,6 +254,9 @@ function Field(valueType) {
             if (r.maxLength) {
                 r.validate = addValidator(r.validate, validators_js_1.Validators.maxLength(r.maxLength));
             }
+            if (r.minLength) {
+                r.validate = addValidator(r.validate, validators_js_1.Validators.minLength(r.minLength));
+            }
             if (!r.valueType && valueType) {
                 r.valueType = valueType();
             }
@@ -264,7 +267,10 @@ function Field(valueType) {
                 r.dbName = r.key;
             var type = r.valueType;
             if (!type) {
-                type = Reflect.getMetadata('design:type', target, key);
+                type =
+                    typeof Reflect.getMetadata == 'function'
+                        ? Reflect.getMetadata('design:type', target, key)
+                        : [];
                 r.valueType = type;
             }
             if (!r.target)

package/src/remult3/RepositoryImplementation.d.ts

@@ -3,14 +3,15 @@ import { LookupColumn } from '../column.js';
 import type { FieldMetadata, FieldOptions, ValueConverter, ValueListItem } from '../column-interfaces.js';
 import { Remult } from '../context.js';
 import type { EntityOptions } from '../entity.js';
+import { Filter } from '../filter/filter-interfaces.js';
 import type { ControllerRef, ControllerRefForControllerBase, EntityFilter, EntityMetadata, EntityOrderBy, EntityRef, EntityRefForEntityBase, FieldRef, FieldsMetadata, FieldsRef, FieldsRefForEntityBase, FindFirstOptions, FindFirstOptionsBase, FindOptions, IdMetadata, LiveQuery, LoadOptions, MembersOnly, QueryOptions, QueryResult, Repository, RepositoryRelations, Subscribable } from './remult3.js';
 import type { RefSubscriber } from './remult3.js';
 import type { entityEventListener } from '../__EntityValueProvider.js';
 import type { DataProvider, EntityDataProvider, EntityDataProviderFindOptions, ErrorInfo } from '../data-interfaces.js';
 import type { Unsubscribe } from '../live-query/SubscriptionChannel.js';
 import { RelationLoader } from './relation-loader.js';
-import { getInternalKey } from './repository-internals.js';
-export declare class RepositoryImplementation<entityType> implements Repository<entityType> {
+import { type RepositoryInternal, getInternalKey } from './repository-internals.js';
+export declare class RepositoryImplementation<entityType> implements Repository<entityType>, RepositoryInternal<entityType> {
     private entity;
     remult: Remult;
     private dataProvider;
@@ -19,6 +20,11 @@ export declare class RepositoryImplementation<entityType> implements Repository<
     [getInternalKey](): this;
     createAfterFilter(orderBy: EntityOrderBy<entityType>, lastRow: entityType): Promise<EntityFilter<entityType>>;
     relations(item: entityType): RepositoryRelations<entityType>;
+    getFocusedRelationRepo(field: FieldMetadata, item: entityType): {
+        toRepo: RepositoryImplementation<any>;
+        returnNull: boolean;
+        returnUndefined: boolean;
+    };
     private __edp;
     private get edp();
     constructor(entity: ClassType<entityType>, remult: Remult, dataProvider: DataProvider, _info: EntityFullInfo<entityType>, defaultFindOptions?: FindOptions<entityType>);
@@ -67,6 +73,7 @@ export declare class RepositoryImplementation<entityType> implements Repository<
     create(item?: Partial<MembersOnly<entityType>>): entityType;
     fixTypes(item: any): Promise<any>;
     findId(id: any, options?: FindFirstOptionsBase<entityType>): Promise<entityType>;
+    translateWhereToFilter(where: EntityFilter<entityType>): Promise<Filter>;
 }
 export type EntityOptionsFactory = (remult: Remult) => EntityOptions;
 export declare function createOldEntity<T>(entity: ClassType<T>, remult: Remult): EntityFullInfo<T>;

package/src/remult3/RepositoryImplementation.js

@@ -127,9 +127,7 @@ var RepositoryImplementation = /** @class */ (function () {
                 var rel = (0, relationInfoMember_js_1.getRelationFieldInfo)(field);
                 if (!rel)
                     throw Error(key + ' is not a relation');
-                var repo = rel.toRepo;
-                var _a = _this.findOptionsBasedOnRelation(rel, field, undefined, item, repo), findOptions = _a.findOptions, returnNull = _a.returnNull, returnUndefined = _a.returnUndefined;
-                var toRepo = new RepositoryImplementation(repo.entity, repo.remult, repo.dataProvider, repo._info, findOptions);
+                var _a = _this.getFocusedRelationRepo(field, item), toRepo = _a.toRepo, returnNull = _a.returnNull, returnUndefined = _a.returnUndefined;
                 if (rel.type === 'toMany')
                     return toRepo;
                 else
@@ -145,6 +143,13 @@ var RepositoryImplementation = /** @class */ (function () {
             },
         });
     };
+    RepositoryImplementation.prototype.getFocusedRelationRepo = function (field, item) {
+        var rel = (0, relationInfoMember_js_1.getRelationFieldInfo)(field);
+        var repo = rel.toRepo;
+        var _a = this.findOptionsBasedOnRelation(rel, field, undefined, item, repo), findOptions = _a.findOptions, returnNull = _a.returnNull, returnUndefined = _a.returnUndefined;
+        var toRepo = new RepositoryImplementation(repo.entity, repo.remult, repo.dataProvider, repo._info, findOptions);
+        return { toRepo: toRepo, returnNull: returnNull, returnUndefined: returnUndefined };
+    };
     Object.defineProperty(RepositoryImplementation.prototype, "edp", {
         get: function () {
             return this.__edp
@@ -1133,7 +1138,6 @@ var RepositoryImplementation = /** @class */ (function () {
             throw new Error('id can be either number or string, but got: ' + typeof id);
         return this.findFirst({}, tslib_1.__assign(tslib_1.__assign({}, options), { where: this.metadata.idMetadata.getIdFilter(id) }), true);
     };
-    /* @internal*/
     RepositoryImplementation.prototype.translateWhereToFilter = function (where) {
         var _a, _b;
         return tslib_1.__awaiter(this, void 0, void 0, function () {
@@ -2929,7 +2933,7 @@ var EntityFullInfo = /** @class */ (function () {
             else
                 this.idMetadata.field = r_2;
         }
-        else {
+        if (!this.idMetadata.field) {
             if (this.fields['id'])
                 this.idMetadata.field = this.fields['id'];
             else

package/src/remult3/remult3.js

@@ -1,30 +1,58 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+/*y1 - workshop
+
+* Experiment with doing this with version control - so the students can follow changes
+* Prepare stackblitz
+
+
+# influencer:
+  * review react summit
+#
+
+//y1 - admin url!
 //y1 - number default storage in knex is decimal and it by default has 8,2 - meaning only 999,999 - I think it should be way bigger than that. in firefly we do at least 18 - https://discord.com/channels/975754286384418847/1195162533447876658
+//y1 - talk about the parameter issue with backend methods
 //y1 - tried to upgrade vitest, nuxt tests are failing with loading uuid - sounds familiar?
+//y1 - I think that the tests you've setup cover next app router - I added to the setup, but not sure where else
+//y1 - select data provider per entity https://discord.com/channels/975754286384418847/976006081748807690/1201415305885397003
+
+
+//p1 - Small thing, I get SvelteKitError: Not found: /vite.svg
+//p1 - understand the to many relation for the admin, based on the to one
+//p1 - relation from order details to order gave a compound id info - and it is not true - same for the relation to product
+//p1 - live query with include
+//p1 - new row when there are relations, looks funny (see product)
+//p1 - the + row in the bottom should extend to the full width
+//p1 - adjust angular tutorial starter kit for latest angular (as is in tutorial)
+
+/*y2 -
+  @Fields.string<Category>({
+    allowApiUpdate: (c) => getEntityRef(c).isNew(),
+  })
+  Description = ""*/
 //y2 - from the crm-demo(https://crm-demo.up.railway.app/deals), after editing a deal: - _updateEntityBasedOnApi
 //y2 - Backend methods are transactions, it's not intuitive and maybe should be optional / opt in
 //y2 - how to run a transaction as a user
-//p1 - enum column
-//p1 - I think there should be a way to throw a forbidden exception
-//p1 - Write some ctrl g
+//p2 - enum column
+//p2 - I think there should be a way to throw a forbidden exception
 //y2 - get backend methods to work when specifying types for date, and entities as poco's
 //y2 - required
 //y2 - reconsider validators
 //y2 - message for invalid value
 //y2 - message for relation that is missing
-//p1 - more column types
+//p2 - more column types
 //p2 -   processError in remult express
 //p2 -   allow find options preprocessor for api calls, to use for authorization
-//p1 - write doc about controlling updates of rows...
+//p2 - write doc about controlling updates of rows...
 //p1 - need a way to extract the fields from the relation - for generating relation based sql
 //p1 - when doing this, work on graphql relation with fields not just field
-//p1 - add docs for apply changes
-//p1 - when subscribe is forbidden - the query still runs after the renew process
-//p1 - 'update tasks set  where id = $1
+//p2 - add docs for apply changes
+//p2 - when subscribe is forbidden - the query still runs after the renew process
+//p2 - 'update tasks set  where id = $1
 //y2 - consider multi tenancies
 //y2 - allow api read to also support instance and filter. - problem with promise
-//p1 - doc this:
+//p2 - doc this:
 /**
  * //p2 - doc this
 remult.apiClient.httpClient = (
@@ -47,12 +75,12 @@ remult.apiClient.url='localhost:3007/api
 */
 //p1 - remult-admin doesn't handle primary key that has compound column
 //p1 - remult-admin didn't show a update for a table with a uniqua that is numeric
-//p1 - crm demo graphql error
-//p1 - fix multiple instances of remult: the defaultRemult and async local hook - and columnsOfType - all can be tests with a vite project loading `remult-admin`
 //p1 -check if checouknt doesn't respect allow read (I think)
+//p1 - when a tasks table exists in a different schema - we get many errors
 //p1 - allow api update only for new rows
 //p1 - getFields didn't work for kobi in the home component
-//p1 - https://codesandbox.io/p/devbox/demo-sql-expression-wqvj4g
+//p1 - add to docs  https://codesandbox.io/p/devbox/demo-sql-expression-wqvj4g
+//y1 - talk about export api is not possible in +server - how did we face that in others, and how do we doc it
 //p2 - document validators
 //p2 - and validators to reference
 //y2 - discuss a default date formatter
@@ -82,3 +110,10 @@ remult.apiClient.url='localhost:3007/api
 //y2 - should enforce integer - currently we probably round / truncate it
 //p1 - adjust react tutorial to esm
 //p1 - write docs on with remult - and usage in init api
+/*y1 - discuss sql stuff:
+     https://discord.com/channels/975754286384418847/975754286384418852/1198997156678357043
+     https://codesandbox.io/p/devbox/demo-sql-expression-forked-f94p6m?file=%2Fsrc%2Findex.ts%3A21%2C3-21%2C12&workspaceId=c0f7eccf-c151-423b-ac8e-0f0f3e1ad350
+     https://codesandbox.io/p/devbox/demo-sql-expression-forked-c2jhyc?file=%2Fsrc%2Findex.ts%3A37%2C50&workspaceId=7e9d0505-ea79-46f1-8973-50cadde4fa96
+
+
+*/

package/src/remult3/repository-internals.d.ts

@@ -1,3 +1,4 @@
+import type { FieldMetadata } from '../column-interfaces.js';
 import type { EntityDataProviderFindOptions } from '../data-interfaces.js';
 import type { Filter } from '../filter/filter-interfaces.js';
 import type { EntityFilter, EntityOrderBy, FindOptions, LoadOptions, Repository } from './remult3.js';
@@ -9,6 +10,11 @@ export interface RepositoryInternal<entityType> {
     getCachedById(id: any, doNotLoadIfNotFound: boolean): entityType;
     getCachedByIdAsync(id: any, doNotLoadIfNotFound: boolean): Promise<entityType>;
     addToCache(item: entityType): any;
+    getFocusedRelationRepo(field: FieldMetadata, item: any): {
+        toRepo: Repository<any>;
+        returnNull: boolean;
+        returnUndefined: boolean;
+    };
 }
 export declare function getRepositoryInternals<entityType>(repo: Repository<entityType>): RepositoryInternal<entityType>;
 export declare const getInternalKey: unique symbol;

package/src/server-action.d.ts

@@ -28,7 +28,7 @@ export declare class myServerAction extends Action<inArgs, result> {
     private types;
     private options;
     originalMethod: (args: any[]) => any;
-    constructor(name: string, types: any[], options: BackendMethodOptions<any>, 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>;
 }
 export interface BackendMethodOptions<type> {
@@ -43,7 +43,7 @@ export interface BackendMethodOptions<type> {
     queue?: boolean;
     /** EXPERIMENTAL: Determines if the user should be blocked while this `BackendMethod` is running*/
     blockUser?: boolean;
-    paramTypes?: any[];
+    paramTypes?: 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> {

package/src/server-action.js

@@ -145,7 +145,7 @@ var myServerAction = /** @class */ (function (_super) {
                                             if (!remult.isAllowedForInstance(undefined, this.options.allowed))
                                                 throw new ForbiddenError();
                                             _a = info;
-                                            return [4 /*yield*/, prepareReceivedArgs(this.types, info.args, remult, ds, res)];
+                                            return [4 /*yield*/, prepareReceivedArgs(this.types(), info.args, remult, ds, res)];
                                         case 1:
                                             _a.args = _c.sent();
                                             _c.label = 2;
@@ -191,18 +191,26 @@ function BackendMethod(options) {
         var originalMethod = descriptor ? descriptor.value : target;
         var result = originalMethod;
         (0, Fields_js_1.checkTarget)(target);
-        if (target.prototype !== undefined) {
-            var types = Reflect.getMetadata('design:paramtypes', target, key);
+        function getTypes() {
+            var types = typeof Reflect.getMetadata == 'function'
+                ? Reflect.getMetadata('design:paramtypes', target, key)
+                : [];
             if (options.paramTypes)
-                types = options.paramTypes;
+                types =
+                    typeof options.paramTypes === 'function'
+                        ? options.paramTypes()
+                        : options.paramTypes;
+            return types;
+        }
+        if (target.prototype !== undefined) {
             // if types are undefined - you've forgot to set: "emitDecoratorMetadata":true
-            var serverAction_1 = new myServerAction(((options === null || options === void 0 ? void 0 : options.apiPrefix) ? options.apiPrefix + '/' : '') + key, types, options, function (args) { return originalMethod.apply(undefined, args); });
+            var serverAction_1 = new myServerAction(((options === null || options === void 0 ? void 0 : options.apiPrefix) ? options.apiPrefix + '/' : '') + key, function () { return getTypes(); }, options, function (args) { return originalMethod.apply(undefined, args); });
             serverAction_1.doWork = function (args, self, url, http) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
                 var _this = this;
                 return tslib_1.__generator(this, function (_a) {
                     switch (_a.label) {
                         case 0:
-                            args = prepareArgsToSend(types, args);
+                            args = prepareArgsToSend(getTypes(), args);
                             if (!(options.blockUser === false)) return [3 /*break*/, 2];
                             return [4 /*yield*/, remult_static_js_1.remultStatic.actionInfo.runActionWithoutBlockingUI(function () { return tslib_1.__awaiter(_this, void 0, void 0, function () { return tslib_1.__generator(this, function (_a) {
                                     switch (_a.label) {
@@ -243,9 +251,6 @@ function BackendMethod(options) {
             else
                 return result;
         }
-        var types = Reflect.getMetadata('design:paramtypes', target, key);
-        if (options.paramTypes)
-            types = options.paramTypes;
         var x = remult_static_js_1.remultStatic.classHelpers.get(target.constructor);
         if (!x) {
             x = new context_js_1.ClassHelper();
@@ -283,7 +288,7 @@ function BackendMethod(options) {
                                                 switch (_e.label) {
                                                     case 0:
                                                         _a = d;
-                                                        return [4 /*yield*/, prepareReceivedArgs(types, d.args, remult_1, remult_1.dataProvider, res)];
+                                                        return [4 /*yield*/, prepareReceivedArgs(getTypes(), d.args, remult_1, remult_1.dataProvider, res)];
                                                     case 1:
                                                         _a.args = _e.sent();
                                                         if (!remult_static_js_1.remultStatic.allEntities.includes(constructor)) return [3 /*break*/, 13];
@@ -404,7 +409,7 @@ function BackendMethod(options) {
                     return tslib_1.__generator(this, function (_h) {
                         switch (_h.label) {
                             case 0:
-                                args = prepareArgsToSend(types, args);
+                                args = prepareArgsToSend(getTypes(), args);
                                 if (!remult_static_js_1.remultStatic.allEntities.includes(target.constructor)) return [3 /*break*/, 8];
                                 defs = (0, getEntityRef_js_1.getEntityRef)(self);
                                 return [4 /*yield*/, defs.__validateEntity()];

package/src/sort.js

@@ -92,8 +92,8 @@ var Sort = /** @class */ (function () {
                     };
                     if (field) {
                         var rel = (0, relationInfoMember_js_1.getRelationFieldInfo)(field);
-                        var op = field.options; //p1 - fix
                         if ((rel === null || rel === void 0 ? void 0 : rel.type) === 'toOne') {
+                            var op = rel.options;
                             if (typeof op.field === 'string') {
                                 addSegment(entityDefs.fields.find(op.field));
                             }