remult 0.22.9-exp.0 → 0.22.9

package/esm/index.d.ts

@@ -1,9 +1,8 @@
-export { OmitEB, FieldsMetadata, FieldRef, IdFieldRef, FieldsRef, EntityMetadata, EntityOrderBy, EntityFilter, FindOptions, QueryResult, QueryOptions, Repository, FindFirstOptions, ComparisonValueFilter, ValueFilter, IdFilter, ContainsStringValueFilter, EntityRef, SortSegments, Paginator, LiveQuery, LiveQueryChangeInfo, Subscribable, RefSubscriber, RefSubscriberBase, RelationOptions, RelationOptionsBase, ObjectMembersOnly, MembersToInclude, RepositoryRelations, } from './src/remult3/remult3';
-export { EntityBase, ControllerBase, FieldType, getFields, ValueListFieldType, getValueList, ValueListFieldOptions, ValueListInfo, CaptionTransformer, } from './src/remult3/RepositoryImplementation';
+export { OmitEB, FieldsMetadata, FieldRef, IdFieldRef, FieldsRef, EntityMetadata, EntityOrderBy, EntityFilter, FindOptions, QueryResult, QueryOptions, Repository, FindFirstOptions, ComparisonValueFilter, ValueFilter, IdFilter, ContainsStringValueFilter, EntityRef, SortSegments, Paginator, LiveQuery, LiveQueryChangeInfo, } from './src/remult3/remult3';
+export { Field, Fields, IdEntity, EntityBase, ControllerBase, FieldType, getFields, ValueListFieldType, getValueList, ValueListFieldOptions, ValueListInfo, CaptionTransformer, } from './src/remult3/RepositoryImplementation';
 export { Entity } from './src/remult3/entity';
 export { getEntityRef } from './src/remult3/getEntityRef';
-export { Field, Fields, StringFieldOptions } from './src/remult3/Fields';
-export { IdEntity } from './src/remult3/IdEntity';
+export { StringFieldOptions } from './src/remult3/RepositoryImplementation';
 export { describeClass } from './src/remult3/DecoratorReplacer';
 export { EntityOptions } from './src/entity';
 export { DataProvider, EntityDataProvider, EntityDataProviderFindOptions, ErrorInfo, RestDataProviderHttpProvider, } from './src/data-interfaces';

package/esm/index.js

@@ -1,8 +1,6 @@
-export { EntityBase, ControllerBase, FieldType, getFields, ValueListFieldType, getValueList, ValueListInfo, CaptionTransformer, } from './src/remult3/RepositoryImplementation';
+export { Field, Fields, IdEntity, EntityBase, ControllerBase, FieldType, getFields, ValueListFieldType, getValueList, ValueListInfo, CaptionTransformer, } from './src/remult3/RepositoryImplementation';
 export { Entity } from './src/remult3/entity';
 export { getEntityRef } from './src/remult3/getEntityRef';
-export { Field, Fields } from './src/remult3/Fields';
-export { IdEntity } from './src/remult3/IdEntity';
 export { describeClass } from './src/remult3/DecoratorReplacer';
 export { RestDataProvider } from './src/data-providers/rest-data-provider'; //V
 export { InMemoryDataProvider } from './src/data-providers/in-memory-database'; //V

package/esm/internals.d.ts

@@ -1,6 +1,7 @@
 export { getRelationInfo } from './src/remult3/relationInfoMember';
-export { decorateColumnSettings } from './src/remult3/RepositoryImplementation';
+export { decorateColumnSettings, controllerRefImpl, getControllerRef, } from './src/remult3/RepositoryImplementation';
 export { getEntitySettings } from './src/remult3/getEntityRef';
 export { __updateEntityBasedOnWhere } from './src/filter/filter-interfaces';
 export { actionInfo } from './src/server-action-info';
 export { RelationInfo } from './src/remult3/remult3';
+export { ClassType } from './classType';

package/esm/internals.js

@@ -1,5 +1,5 @@
 export { getRelationInfo } from './src/remult3/relationInfoMember';
-export { decorateColumnSettings } from './src/remult3/RepositoryImplementation';
+export { decorateColumnSettings, controllerRefImpl, getControllerRef, } from './src/remult3/RepositoryImplementation';
 export { getEntitySettings } from './src/remult3/getEntityRef';
 export { __updateEntityBasedOnWhere } from './src/filter/filter-interfaces';
 export { actionInfo } from './src/server-action-info';

package/esm/live-query/data-provider-live-query-storage.js

@@ -1,8 +1,7 @@
 import { __decorate, __metadata } from "tslib";
 import { initDataProvider } from '../server/initDataProvider';
 import { allEntities, Remult } from '../src/context';
-import { EntityBase } from '../src/remult3/RepositoryImplementation';
-import { Fields } from '../src/remult3/Fields';
+import { EntityBase, Fields } from '../src/remult3/RepositoryImplementation';
 import { Entity } from '../src/remult3/entity';
 export class DataProviderLiveQueryStorage {
     repo;

package/esm/server/expressBridge.d.ts

@@ -3,7 +3,7 @@ import type { UserInfo } from '../src/context';
 import { Remult } from '../src/context';
 import type { DataProvider } from '../src/data-interfaces';
 import type { LiveQueryStorage, SubscriptionServer } from '../src/live-query/SubscriptionServer';
-import { IdEntity } from '../src/remult3/IdEntity';
+import { IdEntity } from '../src/remult3/RepositoryImplementation';
 import type { Repository } from '../src/remult3/remult3';
 import type { queuedJobInfoResponse } from '../src/server-action';
 export interface RemultServerOptions<RequestType> {

package/esm/server/expressBridge.js

@@ -4,8 +4,7 @@ import { Remult, RemultAsyncLocalStorage, allEntities } from '../src/context';
 import { DataApi, serializeError } from '../src/data-api';
 import { liveQueryKeepAliveRoute, streamUrl, } from '../src/live-query/SubscriptionChannel';
 import { InMemoryLiveQueryStorage, LiveQueryPublisher, } from '../src/live-query/SubscriptionServer';
-import { IdEntity } from '../src/remult3/IdEntity';
-import { Fields } from '../src/remult3/Fields';
+import { Fields, IdEntity } from '../src/remult3/RepositoryImplementation';
 import { Entity } from '../src/remult3/entity';
 import { getEntityKey } from '../src/remult3/getEntityRef';
 import { Action, classBackendMethodsArray } from '../src/server-action';

package/esm/src/column.d.ts

@@ -3,7 +3,7 @@ import type { RepositoryImplementation } from './remult3/RepositoryImplementatio
 export declare function makeTitle(name: string): string;
 export declare class LookupColumn<T> {
     private repository;
-    private isManyToOneRelation;
+    id: idType<T>;
     toJson(): any;
     setId(val: any): void;
     waitLoadOf(id: any): Promise<T>;
@@ -12,8 +12,7 @@ export declare class LookupColumn<T> {
         item: T;
     };
     set(item: T): void;
-    id: idType<T>;
-    constructor(repository: RepositoryImplementation<T>, isManyToOneRelation: any);
+    constructor(repository: RepositoryImplementation<T>, id: idType<T>);
     get item(): T;
     waitLoad(): Promise<T>;
 }

package/esm/src/column.js

@@ -12,7 +12,7 @@ export function makeTitle(name) {
 }
 export class LookupColumn {
     repository;
-    isManyToOneRelation;
+    id;
     toJson() {
         if (!this.storedItem)
             return undefined;
@@ -28,12 +28,12 @@ export class LookupColumn {
     waitLoadOf(id) {
         if (id === undefined || id === null)
             return null;
-        return this.repository.getCachedByIdAsync(id, false);
+        return this.repository.getCachedByIdAsync(id);
     }
     get(id) {
         if (id === undefined || id === null)
             return null;
-        return this.repository.getCachedById(id, this.isManyToOneRelation);
+        return this.repository.getCachedById(id);
     }
     storedItem;
     set(item) {
@@ -60,10 +60,9 @@ export class LookupColumn {
             this.id = undefined;
         }
     }
-    id;
-    constructor(repository, isManyToOneRelation) {
+    constructor(repository, id) {
         this.repository = repository;
-        this.isManyToOneRelation = isManyToOneRelation;
+        this.id = id;
     }
     get item() {
         if (this.storedItem)

package/esm/src/context.js

@@ -2,7 +2,7 @@ import { RestDataProvider } from './data-providers/rest-data-provider';
 import { LiveQueryClient } from './live-query/LiveQueryClient';
 import { SseSubscriptionClient } from './live-query/SseSubscriptionClient';
 import { RemultProxy, remult } from './remult-proxy';
-import { RepositoryImplementation, createOldEntity, } from './remult3/RepositoryImplementation';
+import { RepositoryImplementation } from './remult3/RepositoryImplementation';
 import { actionInfo, serverActionField } from './server-action-info';
 import { buildRestDataProvider, isExternalHttpProvider, } from './buildRestDataProvider';
 export class RemultAsyncLocalStorage {
@@ -57,7 +57,7 @@ export class Remult {
             this.repCache.set(dataProvider, (dpCache = new Map()));
         let r = dpCache.get(entity);
         if (!r) {
-            dpCache.set(entity, (r = new RepositoryImplementation(entity, this, dataProvider, createOldEntity(entity, this))));
+            dpCache.set(entity, (r = new RepositoryImplementation(entity, this, dataProvider)));
         }
         return r;
     }

package/esm/src/data-providers/array-entity-data-provider.d.ts

@@ -1,5 +1,4 @@
 import type { EntityDataProvider, EntityDataProviderFindOptions } from '../data-interfaces';
-import { type EntityDbNamesBase } from '../filter/filter-consumer-bridge-to-sql-request';
 import { Filter } from '../filter/filter-interfaces';
 import type { EntityFilter, EntityMetadata } from '../remult3/remult3';
 export declare class ArrayEntityDataProvider implements EntityDataProvider {
@@ -7,13 +6,11 @@ export declare class ArrayEntityDataProvider implements EntityDataProvider {
     private rows?;
     static rawFilter(filter: CustomArrayFilter): EntityFilter<any>;
     constructor(entity: EntityMetadata, rows?: any[]);
-    __names: EntityDbNamesBase;
-    init(): Promise<EntityDbNamesBase>;
     private verifyThatRowHasAllNotNullColumns;
     count(where?: Filter): Promise<number>;
     find(options?: EntityDataProviderFindOptions): Promise<any[]>;
-    translateFromJson(row: any, dbNames: EntityDbNamesBase): {};
-    translateToJson(row: any, dbNames: EntityDbNamesBase): {};
+    translateFromJson(row: any): {};
+    translateToJson(row: any): {};
     private idMatches;
     update(id: any, data: any): Promise<any>;
     delete(id: any): Promise<void>;

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

@@ -1,5 +1,4 @@
 import { CompoundIdField } from '../CompoundIdField';
-import { dbNamesOf, isDbReadonly, } from '../filter/filter-consumer-bridge-to-sql-request';
 import { Filter, customDatabaseFilterToken } from '../filter/filter-interfaces';
 export class ArrayEntityDataProvider {
     entity;
@@ -17,24 +16,16 @@ export class ArrayEntityDataProvider {
         if (!rows)
             rows = [];
         else {
+            for (const r of rows) {
+                this.verifyThatRowHasAllNotNullColumns(r);
+            }
         }
     }
-    __names;
-    async init() {
-        if (this.__names)
-            return this.__names;
-        this.__names = await dbNamesOf(this.entity);
-        for (const r of this.rows) {
-            this.verifyThatRowHasAllNotNullColumns(r, this.__names);
-        }
-        return this.__names;
-    }
-    verifyThatRowHasAllNotNullColumns(r, names) {
+    verifyThatRowHasAllNotNullColumns(r) {
         for (const f of this.entity.fields) {
-            const key = names.$dbNameOf(f);
             if (!f.isServerExpression)
                 if (!f.allowNull) {
-                    if (r[key] === undefined || r[key] === null) {
+                    if (r[f.key] === undefined || r[f.key] === null) {
                         let val = undefined;
                         if (f.valueType === Boolean)
                             val = false;
@@ -42,23 +33,22 @@ export class ArrayEntityDataProvider {
                             val = 0;
                         else if (f.valueType === String)
                             val = '';
-                        r[key] = val;
+                        r[f.key] = val;
                     }
                 }
-                else if (r[key] === undefined)
-                    r[key] = null;
+                else if (r[f.key] === undefined)
+                    r[f.key] = null;
         }
     }
     async count(where) {
         let rows = this.rows;
-        const names = await this.init();
         let j = 0;
         for (let i = 0; i < rows.length; i++) {
             if (!where) {
                 j++;
             }
             else {
-                let x = new FilterConsumerBridgeToObject(rows[i], names);
+                let x = new FilterConsumerBridgeToObject(rows[i]);
                 where.__applyToConsumer(x);
                 if (x.ok)
                     j++;
@@ -68,74 +58,70 @@ export class ArrayEntityDataProvider {
     }
     async find(options) {
         let rows = this.rows;
-        const dbNames = await this.init();
         if (options) {
             if (options.where) {
                 rows = rows.filter((i) => {
-                    let x = new FilterConsumerBridgeToObject(i, dbNames);
+                    let x = new FilterConsumerBridgeToObject(i);
                     options.where.__applyToConsumer(x);
                     return x.ok;
                 });
             }
             if (options.orderBy) {
                 rows = rows.sort((a, b) => {
-                    return options.orderBy.compare(a, b, dbNames.$dbNameOf);
+                    return options.orderBy.compare(a, b);
                 });
             }
             rows = pageArray(rows, options);
         }
         if (rows)
             return rows.map((i) => {
-                return this.translateFromJson(i, dbNames);
+                return this.translateFromJson(i);
             });
     }
-    translateFromJson(row, dbNames) {
+    translateFromJson(row) {
         let result = {};
         for (const col of this.entity.fields) {
-            result[col.key] = col.valueConverter.fromJson(row[dbNames.$dbNameOf(col)]);
+            result[col.key] = col.valueConverter.fromJson(row[col.key]);
         }
         return result;
     }
-    translateToJson(row, dbNames) {
+    translateToJson(row) {
         let result = {};
         for (const col of this.entity.fields) {
-            if (!isDbReadonly(col, dbNames))
-                result[dbNames.$dbNameOf(col)] = col.valueConverter.toJson(row[col.key]);
+            result[col.key] = col.valueConverter.toJson(row[col.key]);
         }
         return result;
     }
-    idMatches(id, names) {
+    idMatches(id) {
         return (item) => {
-            let x = new FilterConsumerBridgeToObject(item, names);
+            let x = new FilterConsumerBridgeToObject(item);
             Filter.fromEntityFilter(this.entity, this.entity.idMetadata.getIdFilter(id)).__applyToConsumer(x);
             return x.ok;
         };
     }
-    async update(id, data) {
-        const names = await this.init();
-        let idMatches = this.idMatches(id, names);
+    update(id, data) {
+        let idMatches = this.idMatches(id);
         let keys = Object.keys(data);
         for (let i = 0; i < this.rows.length; i++) {
             let r = this.rows[i];
             if (idMatches(r)) {
                 let newR = { ...r };
                 for (const f of this.entity.fields) {
-                    if (!isDbReadonly(f, names)) {
+                    if (!f.dbReadOnly && !f.isServerExpression) {
                         if (keys.includes(f.key)) {
-                            newR[names.$dbNameOf(f)] = f.valueConverter.toJson(data[f.key]);
+                            newR[f.key] = f.valueConverter.toJson(data[f.key]);
                         }
                     }
                 }
-                this.verifyThatRowHasAllNotNullColumns(newR, names);
+                this.verifyThatRowHasAllNotNullColumns(newR);
                 this.rows[i] = newR;
-                return Promise.resolve(this.translateFromJson(this.rows[i], names));
+                return Promise.resolve(this.translateFromJson(this.rows[i]));
             }
         }
         throw new Error("couldn't find id to update: " + id);
     }
-    async delete(id) {
-        const names = await this.init();
-        let idMatches = this.idMatches(id, names);
+    delete(id) {
+        let idMatches = this.idMatches(id);
         for (let i = 0; i < this.rows.length; i++) {
             if (idMatches(this.rows[i])) {
                 this.rows.splice(i, 1);
@@ -145,26 +131,25 @@ export class ArrayEntityDataProvider {
         throw new Error("couldn't find id to delete: " + id);
     }
     async insert(data) {
-        const names = await this.init();
-        let j = this.translateToJson(data, names);
         let idf = this.entity.idMetadata.field;
         if (!(idf instanceof CompoundIdField)) {
             if (idf.options.valueConverter?.fieldTypeInDb === 'autoincrement') {
-                j[idf.key] = 1;
+                data[idf.key] = 1;
                 for (const row of this.rows) {
-                    if (row[idf.key] >= j[idf.key])
-                        j[idf.key] = row[idf.key] + 1;
+                    if (row[idf.key] >= data[idf.key])
+                        data[idf.key] = row[idf.key] + 1;
                 }
             }
-            if (j[idf.key])
+            if (data[idf.key])
                 this.rows.forEach((i) => {
-                    if (j[idf.key] == i[idf.key])
+                    if (data[idf.key] == i[idf.key])
                         throw Error('id already exists');
                 });
         }
-        this.verifyThatRowHasAllNotNullColumns(j, names);
+        let j = this.translateToJson(data);
+        this.verifyThatRowHasAllNotNullColumns(j);
         this.rows.push(j);
-        return Promise.resolve(this.translateFromJson(j, names));
+        return Promise.resolve(this.translateFromJson(j));
     }
 }
 function pageArray(rows, options) {
@@ -187,11 +172,9 @@ function pageArray(rows, options) {
 }
 class FilterConsumerBridgeToObject {
     row;
-    dbNames;
     ok = true;
-    constructor(row, dbNames) {
+    constructor(row) {
         this.row = row;
-        this.dbNames = dbNames;
     }
     databaseCustom(databaseCustom) {
         if (databaseCustom && databaseCustom.arrayFilter) {
@@ -204,7 +187,7 @@ class FilterConsumerBridgeToObject {
     }
     or(orElements) {
         for (const element of orElements) {
-            let filter = new FilterConsumerBridgeToObject(this.row, this.dbNames);
+            let filter = new FilterConsumerBridgeToObject(this.row);
             element.__applyToConsumer(filter);
             if (filter.ok) {
                 return;
@@ -213,47 +196,47 @@ class FilterConsumerBridgeToObject {
         this.ok = false;
     }
     isNull(col) {
-        if (this.row[this.dbNames.$dbNameOf(col)] != null)
+        if (this.row[col.key] != null)
             this.ok = false;
     }
     isNotNull(col) {
-        if (this.row[this.dbNames.$dbNameOf(col)] == null)
+        if (this.row[col.key] == null)
             this.ok = false;
     }
     isIn(col, val) {
         for (const v of val) {
-            if (this.row[this.dbNames.$dbNameOf(col)] == col.valueConverter.toJson(v)) {
+            if (this.row[col.key] == col.valueConverter.toJson(v)) {
                 return;
             }
         }
         this.ok = false;
     }
     isEqualTo(col, val) {
-        if (this.row[this.dbNames.$dbNameOf(col)] != col.valueConverter.toJson(val))
+        if (this.row[col.key] != col.valueConverter.toJson(val))
             this.ok = false;
     }
     isDifferentFrom(col, val) {
-        if (this.row[this.dbNames.$dbNameOf(col)] == col.valueConverter.toJson(val))
+        if (this.row[col.key] == col.valueConverter.toJson(val))
             this.ok = false;
     }
     isGreaterOrEqualTo(col, val) {
-        if (this.row[this.dbNames.$dbNameOf(col)] < col.valueConverter.toJson(val))
+        if (this.row[col.key] < col.valueConverter.toJson(val))
             this.ok = false;
     }
     isGreaterThan(col, val) {
-        if (this.row[this.dbNames.$dbNameOf(col)] <= col.valueConverter.toJson(val))
+        if (this.row[col.key] <= col.valueConverter.toJson(val))
             this.ok = false;
     }
     isLessOrEqualTo(col, val) {
-        if (this.row[this.dbNames.$dbNameOf(col)] > col.valueConverter.toJson(val))
+        if (this.row[col.key] > col.valueConverter.toJson(val))
             this.ok = false;
     }
     isLessThan(col, val) {
-        if (this.row[this.dbNames.$dbNameOf(col)] >= col.valueConverter.toJson(val))
+        if (this.row[col.key] >= col.valueConverter.toJson(val))
             this.ok = false;
     }
     containsCaseInsensitive(col, val) {
-        let v = this.row[this.dbNames.$dbNameOf(col)];
+        let v = this.row[col.key];
         if (!v) {
             this.ok = false;
             return;

package/esm/src/data-providers/rest-data-provider.d.ts

@@ -1,6 +1,6 @@
 import type { DataProvider, EntityDataProvider, EntityDataProviderFindOptions, RestDataProviderHttpProvider } from '../data-interfaces';
 import { UrlBuilder } from '../../urlBuilder';
-import { type ApiClient } from '../context';
+import type { ApiClient } from '../context';
 import { Filter } from '../filter/filter-interfaces';
 import type { EntityMetadata } from '../remult3/remult3';
 export declare class RestDataProvider implements DataProvider {

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

@@ -1,9 +1,7 @@
 import { UrlBuilder } from '../../urlBuilder';
 import { buildRestDataProvider, retry } from '../buildRestDataProvider';
-import { Remult } from '../context';
 import { customUrlToken, Filter } from '../filter/filter-interfaces';
 import { actionInfo } from '../server-action-info';
-import { getRelationInfo } from '../remult3/relationInfoMember';
 export class RestDataProvider {
     apiProvider;
     constructor(apiProvider) {
@@ -26,64 +24,22 @@ export class RestDataProvider {
 }
 //@internal
 export function findOptionsToJson(options, meta) {
-    if (options.include) {
-        let newInclude = {};
-        for (const key in options.include) {
-            if (Object.prototype.hasOwnProperty.call(options.include, key)) {
-                let element = options.include[key];
-                if (typeof element === 'object') {
-                    const rel = getRelationInfo(meta.fields.find(key).options);
-                    if (rel) {
-                        element = findOptionsToJson(element, new Remult().repo(rel.toType()).metadata);
-                    }
-                }
-                newInclude[key] = element;
-            }
-        }
-        options = { ...options, include: newInclude };
-    }
-    if (options.where)
-        options = {
-            ...options,
-            where: Filter.entityFilterToJson(meta, options.where),
-        };
+    const r = {
+        ...options,
+        where: Filter.entityFilterToJson(meta, options.where),
+    };
     if (options.load)
-        options = {
-            ...options,
-            load: options.load(meta.fields).map((y) => y.key),
-        };
-    return options;
+        r.load = options.load(meta.fields).map((y) => y.key);
+    return r;
 }
 //@internal
 export function findOptionsFromJson(json, meta) {
     let r = {};
-    for (const key of [
-        'limit',
-        'page',
-        'where',
-        'orderBy',
-        'include',
-    ]) {
+    for (const key of ['limit', 'page', 'where', 'orderBy']) {
         if (json[key] !== undefined) {
             if (key === 'where') {
                 r[key] = Filter.entityFilterFromJson(meta, json.where);
             }
-            else if (key === 'include') {
-                let newInclude = { ...json[key] };
-                for (const key in newInclude) {
-                    if (Object.prototype.hasOwnProperty.call(newInclude, key)) {
-                        let element = newInclude[key];
-                        if (typeof element === 'object') {
-                            const rel = getRelationInfo(meta.fields.find(key).options);
-                            if (rel) {
-                                element = findOptionsFromJson(element, new Remult().repo(rel.toType()).metadata);
-                            }
-                        }
-                        newInclude[key] = element;
-                    }
-                }
-                r[key] = newInclude;
-            }
             else
                 r[key] = json[key];
         }

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

@@ -1,30 +1,36 @@
 import type { ClassType } from '../../classType';
 import type { FieldOptions } from '../column-interfaces';
 import type { Remult } from '../context';
-import type { FindOptions, RelationOptions, RelationOptionsBase } from './remult3';
-import { type ClassFieldDecoratorContextStub } from './RepositoryImplementation';
+import type { FindOptions, RelationOptions, ClassFieldDecorator, ClassFieldDecoratorContextStub } from './remult3';
 export declare class Fields {
     /**
      * Stored as a JSON.stringify - to store as json use Fields.json
      */
-    static object<entityType = any, valueType = any>(...options: (FieldOptions<entityType, valueType> | ((options: FieldOptions<entityType, valueType>, remult: Remult) => void))[]): (target: any, context: string | ClassFieldDecoratorContextStub<entityType, valueType | undefined>, c?: any) => void;
-    static json<entityType = any, valueType = any>(...options: (FieldOptions<entityType, valueType> | ((options: FieldOptions<entityType, valueType>, remult: Remult) => void))[]): (target: any, context: string | ClassFieldDecoratorContextStub<entityType, valueType | undefined>, c?: any) => void;
-    static dateOnly<entityType = any>(...options: (FieldOptions<entityType, Date> | ((options: FieldOptions<entityType, Date>, remult: Remult) => void))[]): (target: any, context: string | ClassFieldDecoratorContextStub<entityType, Date | undefined>, c?: any) => void;
-    static date<entityType = any>(...options: (FieldOptions<entityType, Date> | ((options: FieldOptions<entityType, Date>, remult: Remult) => void))[]): (target: any, context: string | ClassFieldDecoratorContextStub<entityType, Date | undefined>, c?: any) => void;
-    static integer<entityType = any>(...options: (FieldOptions<entityType, Number> | ((options: FieldOptions<entityType, Number>, remult: Remult) => void))[]): (target: any, context: string | ClassFieldDecoratorContextStub<entityType, number | undefined>, c?: any) => void;
-    static autoIncrement<entityType = any>(...options: (FieldOptions<entityType, Number> | ((options: FieldOptions<entityType, Number>, remult: Remult) => void))[]): (target: any, context: string | ClassFieldDecoratorContextStub<entityType, number | undefined>, c?: any) => void;
-    static number<entityType = any>(...options: (FieldOptions<entityType, Number> | ((options: FieldOptions<entityType, Number>, remult: Remult) => void))[]): (target: any, context: string | ClassFieldDecoratorContextStub<entityType, number | undefined>, c?: any) => void;
-    static createdAt<entityType = any>(...options: (FieldOptions<entityType, Date> | ((options: FieldOptions<entityType, Date>, remult: Remult) => void))[]): (target: any, context: string | ClassFieldDecoratorContextStub<entityType, Date | undefined>, c?: any) => void;
-    static updatedAt<entityType = any>(...options: (FieldOptions<entityType, Date> | ((options: FieldOptions<entityType, Date>, remult: Remult) => void))[]): (target: any, context: string | ClassFieldDecoratorContextStub<entityType, Date | undefined>, c?: any) => void;
-    static uuid<entityType = any>(...options: (FieldOptions<entityType, string> | ((options: FieldOptions<entityType, string>, remult: Remult) => void))[]): (target: any, context: string | ClassFieldDecoratorContextStub<entityType, string | undefined>, c?: any) => void;
-    static cuid<entityType = any>(...options: (FieldOptions<entityType, string> | ((options: FieldOptions<entityType, string>, remult: Remult) => void))[]): (target: any, context: string | ClassFieldDecoratorContextStub<entityType, string | undefined>, c?: any) => void;
-    static string<entityType = any>(...options: (StringFieldOptions<entityType> | ((options: StringFieldOptions<entityType>, remult: Remult) => void))[]): (target: any, context: string | ClassFieldDecoratorContextStub<entityType, string | undefined>, c?: any) => void;
-    static boolean<entityType = any>(...options: (FieldOptions<entityType, boolean> | ((options: FieldOptions<entityType, boolean>, remult: Remult) => void))[]): (target: any, context: string | ClassFieldDecoratorContextStub<entityType, boolean | undefined>, c?: any) => void;
-    static reference<entityType, toEntityType>(toEntityType: () => ClassType<toEntityType>, options?: RelationOptionsBase<entityType, toEntityType>): (target: any, context: string | ClassFieldDecoratorContextStub<entityType, toEntityType>, c?: any) => void;
-    static many<entityType, toEntityType>(toEntityType: () => ClassType<toEntityType>, options: (RelationOptions<entityType, toEntityType, toEntityType, FindOptions<toEntityType>> & {
-        fromEntityType?: ClassType<entityType>;
-    }) | keyof toEntityType): (target: any, context: string | ClassFieldDecoratorContextStub<entityType, any>, c?: any) => void;
-    static one<entityType, toEntityType>(entity: ClassType<entityType>, toEntityType: () => ClassType<toEntityType>, options?: RelationOptions<entityType, toEntityType, entityType> | keyof entityType): (target: any, context: string | ClassFieldDecoratorContextStub<entityType, any>, c?: any) => void;
+    static object<entityType = any, valueType = any>(...options: (FieldOptions<entityType, valueType> | ((options: FieldOptions<entityType, valueType>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, valueType | undefined>;
+    static json<entityType = any, valueType = any>(...options: (FieldOptions<entityType, valueType> | ((options: FieldOptions<entityType, valueType>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, valueType | undefined>;
+    static dateOnly<entityType = any>(...options: (FieldOptions<entityType, Date> | ((options: FieldOptions<entityType, Date>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, Date | undefined>;
+    static date<entityType = any>(...options: (FieldOptions<entityType, Date> | ((options: FieldOptions<entityType, Date>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, Date | undefined>;
+    static integer<entityType = any>(...options: (FieldOptions<entityType, Number> | ((options: FieldOptions<entityType, Number>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, number | undefined>;
+    static autoIncrement<entityType = any>(...options: (FieldOptions<entityType, Number> | ((options: FieldOptions<entityType, Number>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, number | undefined>;
+    static number<entityType = any>(...options: (FieldOptions<entityType, Number> | ((options: FieldOptions<entityType, Number>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, number | undefined>;
+    static createdAt<entityType = any>(...options: (FieldOptions<entityType, Date> | ((options: FieldOptions<entityType, Date>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, Date | undefined>;
+    static updatedAt<entityType = any>(...options: (FieldOptions<entityType, Date> | ((options: FieldOptions<entityType, Date>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, Date | undefined>;
+    static uuid<entityType = any>(...options: (FieldOptions<entityType, string> | ((options: FieldOptions<entityType, string>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, string | undefined>;
+    static cuid<entityType = any>(...options: (FieldOptions<entityType, string> | ((options: FieldOptions<entityType, string>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, string | undefined>;
+    static string<entityType = any>(...options: (StringFieldOptions<entityType> | ((options: StringFieldOptions<entityType>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, string | undefined>;
+    static boolean<entityType = any>(...options: (FieldOptions<entityType, boolean> | ((options: FieldOptions<entityType, boolean>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, boolean | undefined>;
+}
+export declare class Relations {
+    /** A to one relation with an automatically generated field */
+    static toOne<entityType, toEntityType>(toEntityType: () => ClassType<toEntityType>, options?: FieldOptions<entityType, toEntityType> & Pick<RelationOptions<entityType, toEntityType, any, any>, 'defaultIncluded'>): ClassFieldDecorator<entityType, toEntityType | undefined>;
+    /** A to one relation with fields defined in the second parameter */
+    static toOne<entityType, toEntityType>(toEntityType: () => ClassType<toEntityType>, fieldInMyEntity?: keyof entityType): ClassFieldDecorator<entityType, toEntityType | undefined>;
+    /** A to one relation with fields defined in the field/fields parameter */
+    static toOne<entityType, toEntityType>(toEntityType: () => ClassType<toEntityType>, options: Omit<RelationOptions<entityType, toEntityType, entityType>, keyof Pick<RelationOptions<entityType, toEntityType, entityType>, 'field'>>): ClassFieldDecorator<entityType, toEntityType | undefined>;
+    /** A to one relation with fields defined in the field/fields parameter */
+    static toOne<entityType, toEntityType>(toEntityType: () => ClassType<toEntityType>, options: Omit<RelationOptions<entityType, toEntityType, entityType>, keyof Pick<RelationOptions<entityType, toEntityType, entityType>, 'fields'>>): ClassFieldDecorator<entityType, toEntityType | undefined>;
+    static toMany<entityType, toEntityType>(toEntityType: () => ClassType<toEntityType>, fieldInToEntity?: keyof toEntityType): ClassFieldDecorator<entityType, toEntityType[] | undefined>;
+    static toMany<entityType, toEntityType>(toEntityType: () => ClassType<toEntityType>, options: RelationOptions<entityType, toEntityType, toEntityType, FindOptions<toEntityType>>): ClassFieldDecorator<entityType, toEntityType[] | undefined>;
 }
 /**Decorates fields that should be used as fields.
  * for more info see: [Field Types](https://remult.dev/docs/field-types.html)
@@ -39,7 +45,7 @@ export declare class Fields {
  * @Fields.string((options,remult) => options.includeInApi = true)
  * title='';
  */
-export declare function Field<entityType = any, valueType = any>(valueType: () => ClassType<valueType>, ...options: (FieldOptions<entityType, valueType> | ((options: FieldOptions<entityType, valueType>, remult: Remult) => void))[]): (target: any, context: ClassFieldDecoratorContextStub<entityType, valueType | undefined> | string, c?: any) => void;
+export declare function Field<entityType = any, valueType = any>(valueType: (() => 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;
 }