remult 0.23.0-exp.8 → 0.23.0

package/README.md

@@ -277,6 +277,7 @@ with a Node.js Express backend.
 - [Tutorial with Angular](https://remult.dev/tutorials/angular/)
 - [Tutorial with Vue](https://remult.dev/tutorials/vue/)
 - [Tutorial with Next.js](https://remult.dev/tutorials/react-next/)
+- [Tutorial with Sveltekit](https://remult.dev/tutorials/sveltekit/)
 
 ## Documentation
 

package/esm/graphql.js

@@ -1,3 +1,4 @@
+import { getRelationInfo } from './internals';
 import { Remult, remult } from './index';
 import { DataApi } from './src/data-api';
 const v2ConnectionAndPagination = false;
@@ -219,6 +220,14 @@ _Side note: \`Math.ceil(totalCount / limit)\` to determine how many pages there
                     comment: `
 For **page by page** pagination.
 Select a dedicated page.`,
+                },
+                {
+                    key: 'offset',
+                    value: 'Int',
+                    comment: `
+For **page by page** pagination.
+Set the offset needed.
+_Side node: if \`page\` arg is set, \`offset\` will be ignored._`,
                 },
                 {
                     key: 'orderBy',
@@ -447,6 +456,11 @@ Select a dedicated page.`,
             }
             const whereTypeFields = [];
             for (const f of meta.fields) {
+                const ri = getRelationInfo(f.options);
+                // let's not consider toMany relations for now
+                if (ri?.type === 'toMany') {
+                    break;
+                }
                 if (f.options.includeInApi === false)
                     continue;
                 let type = 'String';
@@ -751,7 +765,10 @@ function toCamelCase(str) {
         .join('');
 }
 function bridgeQueryOptionsToDataApiGet(arg1) {
-    const { limit, page, orderBy, where } = arg1;
+    let { limit, page, orderBy, where, offset } = arg1;
+    if (!page && offset) {
+        page = Math.floor(offset / limit) + 1;
+    }
     return (key) => {
         if (limit && key === '_limit') {
             return limit;
@@ -788,7 +805,7 @@ export function translateWhereToRestBody(fields, { where }) {
         return undefined;
     const result = {};
     for (const field of fields) {
-        if (field.includedInApi === false)
+        if (field.options.includeInApi === false)
             continue;
         const condition = where[field.key];
         if (condition) {

package/esm/index.d.ts

@@ -1,5 +1,7 @@
 import type { ClassType } from './classType';
-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, EntityIdFields, } from './src/remult3/remult3';
+export type { ClassType } from './classType';
+export { MembersOnly, FieldsMetadata, FieldRef, IdFieldRef, FieldsRef, EntityMetadata, EntityOrderBy, EntityFilter, FindOptions, FindOptionsBase, QueryResult, QueryOptions, Repository, FindFirstOptions, ComparisonValueFilter, ValueFilter, IdFilter, ContainsStringValueFilter, EntityRef, SortSegments, Paginator, LiveQuery, LiveQueryChangeInfo, Subscribable, RefSubscriber, RefSubscriberBase, RelationOptions, ObjectMembersOnly, MembersToInclude, RepositoryRelations, EntityIdFields, ClassFieldDecorator, ClassFieldDecoratorContextStub, //n1 consider removing in ts5
+LifecycleEvent, FieldsRefBase, FieldsRefForEntityBase, RepositoryRelationsForEntityBase, ControllerRefForControllerBase, ControllerRefBase, ControllerRef, EntityRefForEntityBase, IdMetadata, FindFirstOptionsBase, } from './src/remult3/remult3';
 export { 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';
@@ -8,7 +10,7 @@ export { IdEntity } from './src/remult3/IdEntity';
 export { describeClass } from './src/remult3/DecoratorReplacer';
 export { EntityOptions } from './src/entity';
 export { DataProvider, EntityDataProvider, EntityDataProviderFindOptions, ErrorInfo, RestDataProviderHttpProvider, } from './src/data-interfaces';
-export { SqlCommand, SqlImplementation, SqlResult } from './src/sql-command';
+export { SqlCommand, SqlCommandWithParameters, SqlImplementation, SqlResult, } from './src/sql-command';
 export { FieldMetadata, FieldOptions, FieldValidator, ValueConverter, ValueListItem, // reconsider, maybe it should go to remult angular as the abstraction ?
 ValueOrExpression, } from './src/column-interfaces';
 export { RestDataProvider } from './src/data-providers/rest-data-provider';
@@ -16,18 +18,30 @@ export { InMemoryDataProvider } from './src/data-providers/in-memory-database';
 export { ArrayEntityDataProvider } from './src/data-providers/array-entity-data-provider';
 export { WebSqlDataProvider } from './src/data-providers/web-sql-data-provider';
 export { SqlDatabase } from './src/data-providers/sql-database';
-export { CustomSqlFilterObject, CustomSqlFilterBuilder, dbNamesOf, } from './src/filter/filter-consumer-bridge-to-sql-request';
+export { CustomSqlFilterObject, CustomSqlFilterBuilder, dbNamesOf, CustomSqlFilterBuilderFunction, EntityDbNames, } from './src/filter/filter-consumer-bridge-to-sql-request';
 export { JsonDataProvider, JsonEntityStorage, } from './src/data-providers/json-data-provider';
 export { Controller, BackendMethodOptions, BackendMethod, ProgressListener, } from './src/server-action';
 export { Allowed, Allow, Remult, RemultContext, ApiClient, isBackend, AllowedForInstance, EventDispatcher, EventSource, UserInfo, } from './src/context';
 export { ExternalHttpProvider } from './src/buildRestDataProvider';
 export { SortSegment, Sort } from './src/sort';
 export { CompoundIdField } from './src/CompoundIdField';
-export { Filter } from './src/filter/filter-interfaces';
+export { Filter, FilterConsumer, customFilterInfo, } from './src/filter/filter-interfaces';
 export { UrlBuilder } from './urlBuilder';
 export { Validators } from './src/validators';
 export { ValueConverters } from './src/valueConverters';
 export { remult } from './src/remult-proxy';
 export { SubscriptionServer, LiveQueryStorage, StoredQuery, InMemoryLiveQueryStorage, } from './src/live-query/SubscriptionServer';
 export { SubscriptionListener, SubscriptionClientConnection, SubscriptionClient, SubscriptionChannel, LiveQueryChange, Unsubscribe, } from './src/live-query/SubscriptionChannel';
+/**
+ * A convenient shortcut function to quickly obtain a repository for a specific entity type in Remult.
+ *
+ * @param entity The entity class type for which you want to get a repository.
+ * @returns A repository instance for the specified entity type.
+ *
+ * Example usage:
+ * ```ts
+ * await repo(Task).find()
+ * await repo(Customer).insert()
+ * ```
+ */
 export declare function repo<entityType>(entity: ClassType<entityType>): import("./src/remult3/remult3").Repository<entityType>;

package/esm/index.js

@@ -16,7 +16,7 @@ export { Controller, BackendMethod, ProgressListener, } from './src/server-actio
 export { Allow, Remult, isBackend, EventSource, } from './src/context';
 export { Sort } from './src/sort';
 export { CompoundIdField } from './src/CompoundIdField';
-export { Filter } from './src/filter/filter-interfaces';
+export { Filter, } from './src/filter/filter-interfaces';
 export { UrlBuilder } from './urlBuilder';
 export { Validators } from './src/validators';
 export { ValueConverters } from './src/valueConverters';
@@ -25,6 +25,18 @@ import { remult } from './src/remult-proxy';
 //export { getId } from './src/remult3/getId';
 export { InMemoryLiveQueryStorage, } from './src/live-query/SubscriptionServer';
 export { SubscriptionChannel, } from './src/live-query/SubscriptionChannel';
+/**
+ * A convenient shortcut function to quickly obtain a repository for a specific entity type in Remult.
+ *
+ * @param entity The entity class type for which you want to get a repository.
+ * @returns A repository instance for the specified entity type.
+ *
+ * Example usage:
+ * ```ts
+ * await repo(Task).find()
+ * await repo(Customer).insert()
+ * ```
+ */
 export function repo(entity) {
     return remult.repo(entity);
 }

package/esm/internals.d.ts

@@ -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/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/postgres/schema-builder.d.ts

@@ -9,6 +9,7 @@ export declare class PostgresSchemaBuilder {
     private removeQuotes;
     private whereTableAndSchema;
     private schemaAndName;
+    private schemaOnly;
     verifyStructureOfAllEntities(remult?: Remult): Promise<void>;
     ensureSchema(entities: EntityMetadata<any>[]): Promise<void>;
     createIfNotExist(entity: EntityMetadata): Promise<void>;

package/esm/postgres/schema-builder.js

@@ -79,6 +79,16 @@ export class PostgresSchemaBuilder {
         }
         return e.$entityName;
     }
+    schemaOnly(e) {
+        if (e.$entityName.includes('.')) {
+            return e.$entityName.split('.')[0];
+        }
+        if (this.specifiedSchema) {
+            return this.specifiedSchema;
+        }
+        // Should default to `public`
+        return 'public';
+    }
     async verifyStructureOfAllEntities(remult) {
         if (!remult) {
             remult = defaultRemult;
@@ -108,6 +118,7 @@ export class PostgresSchemaBuilder {
             }
             catch (err) {
                 console.error('failed verify structure of ' + e.$entityName + ' ', err);
+                throw err;
             }
         }
     }
@@ -134,7 +145,8 @@ export class PostgresSchemaBuilder {
                             result += ' primary key';
                     }
                 }
-                let sql = `CREATE table ${this.schemaAndName(e)} (${result}\r\n)`;
+                let sql = `CREATE SCHEMA IF NOT EXISTS ${this.schemaOnly(e)};
+CREATE table ${this.schemaAndName(e)} (${result}\r\n)`;
                 if (PostgresSchemaBuilder.logToConsole)
                     console.info(sql);
                 await this.pool.execute(sql);

package/esm/remult-express.js

@@ -21,6 +21,6 @@ export function remultExpress(options) {
         getRemult: (req) => server.getRemult(req),
         openApiDoc: (options) => server.openApiDoc(options),
         withRemult: (req, res, next) => server.withRemult(req, res, next),
-        // [ ]- add with remult promise
+        // [ ] V1.5 add with remult promise
     });
 }

package/esm/remult-hapi.d.ts

@@ -0,0 +1,6 @@
+import type { Request, Plugin } from '@hapi/hapi';
+import { type RemultServerCore, type RemultServerOptions } from './server';
+export declare function remultHapi(options: RemultServerOptions<Request>): RemultHapiServer;
+export type RemultHapiServer = Plugin<any, any> & RemultServerCore<Request> & {
+    withRemult<T>(req: Request, what: () => Promise<T>): Promise<T>;
+};

package/esm/remult-hapi.js

@@ -0,0 +1,112 @@
+import { createRemultServer, } from './server';
+import { PassThrough } from 'stream';
+export function remultHapi(options) {
+    const api = createRemultServer(options, {
+        buildGenericRequestInfo: (req) => ({
+            method: req.method,
+            params: req.params,
+            query: req.query,
+            url: req.url.pathname,
+            on: (e, do1) => {
+                req.raw.req.on('close', do1);
+            },
+        }),
+        getRequestBody: async (req) => req.payload,
+    });
+    const routesPlugin = {
+        name: 'remultPlugin',
+        register: async (server) => {
+            function hapiHandler(handler) {
+                return (request, h) => {
+                    return new Promise((res, rej) => {
+                        let status = 200;
+                        let stream;
+                        let r = {
+                            status(statusCode) {
+                                status = statusCode;
+                                console.log(statusCode);
+                                return r;
+                            },
+                            end() {
+                                res(h.response().code(status));
+                            },
+                            json(data) {
+                                res(h.response(data).code(status));
+                            },
+                            write(data) {
+                                stream.write(data);
+                            },
+                            writeHead(status, headers) {
+                                stream = new PassThrough();
+                                res(h
+                                    .response(stream)
+                                    .header('content-type', 'text/event-stream')
+                                    .header('content-encoding', 'identity'));
+                            },
+                        };
+                        try {
+                            Object.assign(request, {
+                                on(event, listener) {
+                                    request.raw.req.on('close', () => {
+                                        listener();
+                                        console.log('Connection closed');
+                                    });
+                                },
+                            });
+                            handler(request, r, () => { });
+                        }
+                        catch (err) {
+                            rej(err);
+                        }
+                    });
+                };
+            }
+            let hapiRouter = {
+                route(path) {
+                    path = path.replace(/:id\b/g, '{id}');
+                    let r = {
+                        get(handler) {
+                            server.route({
+                                method: 'GET',
+                                path,
+                                handler: hapiHandler(handler),
+                            });
+                            return r;
+                        },
+                        post(handler) {
+                            server.route({
+                                method: 'POST',
+                                path,
+                                handler: hapiHandler(handler),
+                            });
+                            return r;
+                        },
+                        put(handler) {
+                            server.route({
+                                method: 'PUT',
+                                path,
+                                handler: hapiHandler(handler),
+                            });
+                            return r;
+                        },
+                        delete(handler) {
+                            server.route({
+                                method: 'DELETE',
+                                path,
+                                handler: hapiHandler(handler),
+                            });
+                            return r;
+                        },
+                    };
+                    return r;
+                },
+            };
+            api.registerRouter(hapiRouter);
+        },
+    };
+    return Object.assign(routesPlugin, {
+        getRemult: (x) => api.getRemult(x),
+        openApiDoc: (x) => api.openApiDoc(x),
+        withRemult: (req, what) => api.withRemultPromise(req, what),
+    });
+}

package/esm/remult-knex/index.js

@@ -7,6 +7,7 @@ import { getRepository, isAutoIncrement, } from '../src/remult3/RepositoryImplem
 import { Sort } from '../src/sort';
 import { ValueConverters } from '../src/valueConverters';
 import { resultCompoundIdFilter as resultCompoundIdFilter } from '../src/resultCompoundIdFilter';
+import { getRepositoryInternals } from '../src/remult3/repository-internals';
 export class KnexDataProvider {
     knex;
     constructor(knex) {
@@ -54,7 +55,7 @@ export class KnexDataProvider {
         const repo = getRepository(entity);
         var b = new FilterConsumerBridgeToKnexRequest(await dbNamesOf(repo.metadata));
         b._addWhere = false;
-        await (await repo.translateWhereToFilter(condition)).__applyToConsumer(b);
+        await (await getRepositoryInternals(repo).translateWhereToFilter(condition)).__applyToConsumer(b);
         let r = await b.resolveWhere();
         return (knex) => r.forEach((y) => y(knex));
     }
@@ -314,7 +315,7 @@ export class KnexSchemaBuilder {
         if (!remult)
             remult = remultContext;
         const entities = allEntities.map((x) => remult.repo(x).metadata);
-        this.ensureSchema(entities);
+        await this.ensureSchema(entities);
     }
     async ensureSchema(entities) {
         for (const entity of entities) {
@@ -329,6 +330,7 @@ export class KnexSchemaBuilder {
             }
             catch (err) {
                 console.error('failed ensure schema of ' + e.$entityName + ' ', err);
+                throw err;
             }
         }
     }

package/esm/remult-mongo.d.ts

@@ -1,4 +1,4 @@
-import type { ClientSession, Db, MongoClient } from 'mongodb';
+import { type ClientSession, type Db, type MongoClient } from 'mongodb';
 import type { DataProvider, EntityDataProvider, EntityFilter, EntityMetadata, Remult } from '.';
 import type { RepositoryOverloads } from './src/remult3/RepositoryImplementation';
 export declare class MongoDataProvider implements DataProvider {

package/esm/remult-mongo.js

@@ -1,8 +1,10 @@
+import { ObjectId, } from 'mongodb';
 import { CompoundIdField, Filter } from '.';
 import { dbNamesOf } from './src/filter/filter-consumer-bridge-to-sql-request';
 import { remult as remultContext } from './src/remult-proxy';
 import { getRepository } from './src/remult3/RepositoryImplementation';
 import { resultCompoundIdFilter } from './src/resultCompoundIdFilter';
+import { getRepositoryInternals } from './src/remult3/repository-internals';
 export class MongoDataProvider {
     db;
     client;
@@ -50,7 +52,7 @@ export class MongoDataProvider {
         const repo = getRepository(entity);
         var b = new FilterConsumerBridgeToMongo(await dbNamesOf(repo.metadata));
         b._addWhere = false;
-        await (await repo.translateWhereToFilter(condition)).__applyToConsumer(b);
+        await (await getRepositoryInternals(repo).translateWhereToFilter(condition)).__applyToConsumer(b);
         let r = await b.resolveWhere();
         return r;
     }
@@ -74,14 +76,14 @@ class MongoEntityDataProvider {
             let val = row[nameProvider.$dbNameOf(col)];
             if (isNull(val))
                 val = null;
-            result[col.key] = col.valueConverter.fromDb(val);
+            result[col.key] = fromDb(col, val);
         }
         return result;
     }
     translateToDb(row, nameProvider) {
         let result = {};
         for (const col of this.entity.fields) {
-            let val = col.valueConverter.toDb(row[col.key]);
+            let val = toDb(col, row[col.key]);
             if (val === null)
                 val = NULL;
             result[nameProvider.$dbNameOf(col)] = val;
@@ -220,7 +222,7 @@ class FilterConsumerBridgeToMongo {
     isIn(col, val) {
         this.result.push(() => ({
             [this.nameProvider.$dbNameOf(col)]: {
-                $in: val.map((x) => col.valueConverter.toDb(x)),
+                $in: val.map((x) => toDb(col, x)),
             },
         }));
     }
@@ -252,7 +254,7 @@ class FilterConsumerBridgeToMongo {
     add(col, val, operator) {
         this.result.push(() => ({
             [this.nameProvider.$dbNameOf(col)]: {
-                [operator]: isNull(val) ? val : col.valueConverter.toDb(val),
+                [operator]: isNull(val) ? val : toDb(col, val),
             },
         }));
     }
@@ -269,3 +271,13 @@ class FilterConsumerBridgeToMongo {
         //   })());
     }
 }
+function toDb(col, val) {
+    if (col.valueConverter.fieldTypeInDb == 'dbid')
+        return val ? new ObjectId(val) : val === null ? null : undefined;
+    return col.valueConverter.toDb(val);
+}
+function fromDb(col, val) {
+    if (col.valueConverter.fieldTypeInDb == 'dbid')
+        return val ? val.toHexString() : val === null ? null : undefined;
+    return col.valueConverter.fromDb(val);
+}

package/esm/remult-sveltekit.d.ts

@@ -1,4 +1,6 @@
 import type { Handle, RequestEvent } from '@sveltejs/kit';
 import type { RemultServerCore, RemultServerOptions } from './server';
 export declare function remultSveltekit(options?: RemultServerOptions<RequestEvent>): RemultSveltekitServer;
-export type RemultSveltekitServer = RemultServerCore<RequestEvent> & Handle;
+export type RemultSveltekitServer = RemultServerCore<RequestEvent> & Handle & {
+    withRemult<T>(request: RequestEvent, what: () => Promise<T>): Promise<T>;
+};

package/esm/remult-sveltekit.js

@@ -67,5 +67,8 @@ export function remultSveltekit(options) {
     return Object.assign(handler, {
         getRemult: (req) => result.getRemult(req),
         openApiDoc: (options) => result.openApiDoc(options),
+        withRemult(request, what) {
+            return result.withRemultPromise(request, what);
+        },
     });
 }

package/esm/server/expressBridge.d.ts

@@ -112,6 +112,14 @@ export declare class EntityQueueStorage implements QueueStorage {
     getJobInfo(queuedJobId: string): Promise<queuedJobInfo>;
     createJob(url: string, userId: string): Promise<string>;
 }
+export declare class RouteImplementation<RequestType> {
+    private coreOptions;
+    constructor(coreOptions: ServerCoreOptions<RequestType>);
+    map: Map<string, Map<string, GenericRequestHandler>>;
+    route(path: string): SpecificRoute;
+    handle(req: RequestType, gRes?: GenericResponse): Promise<ServerHandleResponse | undefined>;
+    middleware(origReq: RequestType, res: GenericResponse, next: VoidFunction): void;
+}
 export declare class JobsInQueueEntity extends IdEntity {
     userId: string;
     url: string;

package/esm/server/expressBridge.js

@@ -116,7 +116,7 @@ export class RemultServerImplementation {
         });
     }
     getEntities() {
-        //TODO - consider using entitiesMetaData - but it may require making it all awaitable
+        //TODO V2 - consider using entitiesMetaData - but it may require making it all awaitable
         var r = new Remult();
         return this.options.entities.map((x) => r.repo(x).metadata);
     }
@@ -763,7 +763,7 @@ export class EntityQueueStorage {
         return (this.sync = this.sync.then(() => what()));
     }
     async getJobInfo(queuedJobId) {
-        let q = await this.repo.findId(queuedJobId, { useCache: false });
+        let q = await this.repo.findId(queuedJobId);
         let lastProgress = undefined;
         return {
             userId: q.userId,
@@ -811,7 +811,7 @@ export class EntityQueueStorage {
         return q.id;
     }
 }
-class RouteImplementation {
+export class RouteImplementation {
     coreOptions;
     constructor(coreOptions) {
         this.coreOptions = coreOptions;
@@ -845,7 +845,7 @@ class RouteImplementation {
         return route;
     }
     async handle(req, gRes) {
-        return new Promise((res) => {
+        return new Promise((res, rej) => {
             const response = new (class {
                 write(data) {
                     ;
@@ -881,7 +881,12 @@ class RouteImplementation {
                     });
                 }
             })();
-            this.middleware(req, response, () => res(undefined));
+            try {
+                this.middleware(req, response, () => res(undefined));
+            }
+            catch (err) {
+                rej(err);
+            }
         });
     }
     middleware(origReq, res, next) {
@@ -920,7 +925,7 @@ class RouteImplementation {
         }
         let idPosition = path.lastIndexOf('/');
         if (idPosition >= 0) {
-            lowerPath = path.substring(0, idPosition) + '/:id';
+            lowerPath = lowerPath.substring(0, idPosition) + '/:id';
             m = this.map.get(lowerPath);
             if (m) {
                 let h = m.get(req.method.toLowerCase());
@@ -929,7 +934,7 @@ class RouteImplementation {
                         req.params = {};
                         origReq['_tempParams'] = req.params;
                     }
-                    req.params.id = path.substring(idPosition + 1);
+                    req.params.id = path.substring(idPosition + 1).replace(/%2C/g, ',');
                     h(origReq, res, next);
                     return;
                 }

package/esm/src/CompoundIdField.d.ts

@@ -6,7 +6,7 @@ export declare class CompoundIdField implements FieldMetadata<string> {
     constructor(...columns: FieldMetadata[]);
     apiUpdateAllowed(item: any): boolean;
     displayValue(item: any): string;
-    includedInApi: boolean;
+    includedInApi(item: any): boolean;
     toInput(value: string, inputType?: string): string;
     fromInput(inputValue: string, inputType?: string): string;
     getDbName(): Promise<string>;

package/esm/src/CompoundIdField.js

@@ -9,7 +9,9 @@ export class CompoundIdField {
     displayValue(item) {
         throw new Error('Method not implemented.');
     }
-    includedInApi;
+    includedInApi(item) {
+        throw new Error('Method not implemented.');
+    }
     toInput(value, inputType) {
         throw new Error('Method not implemented.');
     }

package/esm/src/column-interfaces.d.ts

@@ -1,6 +1,6 @@
 import type { ClassType } from '../classType';
-import type { Allowed, AllowedForInstance } from './context';
-import type { EntityMetadata, FieldRef, LifeCycleEvent, OmitEB } from './remult3/remult3';
+import type { AllowedForInstance } from './context';
+import type { EntityMetadata, FieldRef, LifecycleEvent } from './remult3/remult3';
 export interface FieldOptions<entityType = any, valueType = any> {
     /** A human readable name for the field. Can be used to achieve a consistent caption for a field throughout the app
      * @example
@@ -11,7 +11,7 @@ export interface FieldOptions<entityType = any, valueType = any> {
     allowNull?: boolean;
     /** If this field data is included in the api.
      * @see [allowed](http://remult.dev/docs/allowed.html)*/
-    includeInApi?: Allowed;
+    includeInApi?: AllowedForInstance<entityType>;
     /** If this field data can be updated in the api.
      * @see [allowed](http://remult.dev/docs/allowed.html)*/
     allowApiUpdate?: AllowedForInstance<entityType>;
@@ -37,7 +37,7 @@ export interface FieldOptions<entityType = any, valueType = any> {
      */
     validate?: ((entity: entityType, fieldRef: FieldRef<entityType, valueType>) => any | Promise<any>) | ((entity: entityType, fieldRef: FieldRef<entityType, valueType>) => any | Promise<any>)[];
     /** Will be fired before this field is saved to the server/database */
-    saving?: (entity: entityType, e: LifeCycleEvent<entityType>, fieldRef: FieldRef<entityType, valueType>) => any | Promise<any>;
+    saving?: (entity: entityType, fieldRef: FieldRef<entityType, valueType>, e: LifecycleEvent<entityType>) => any | Promise<any>;
     /**  An expression that will determine this fields value on the backend and be provided to the front end*/
     serverExpression?: (entity: entityType) => valueType | Promise<valueType>;
     /** The name of the column in the database that holds the data for this field. If no name is set, the key will be used instead.
@@ -69,8 +69,20 @@ export interface FieldOptions<entityType = any, valueType = any> {
     defaultValue?: (entity: entityType) => valueType | Promise<valueType>;
     /** The html input type for this field */
     inputType?: string;
-    /** Determines if the referenced entity will be loaded immediately or on demand.
-     * @see[Lazy loading of related entities](http://remult.dev/docs/lazy-loading-of-related-entities.html)
+    /**
+     * @deprecated The 'lazy' option is deprecated and will be removed in future versions.
+     * Use 'Relations.toOne' instead.
+     *
+     * Example usage:
+     * ```
+     * // Deprecated usage with 'lazy' option
+     * @Field(() => Customer, { lazy: true })
+     * customer?: Customer;
+     *
+     * // Preferred usage with 'Relations.toOne'
+     * @Relations.toOne(() => Customer)
+     * customer?: Customer;
+     * ```
      */
     lazy?: boolean;
     /** The value type for this field */
@@ -120,9 +132,9 @@ export interface FieldMetadata<valueType = any, entityType = any> {
      * @example
      * repo.fields.createDate.displayValue(task) //will display the date as defined in the `displayValue` option defined for it.
      */
-    displayValue(item: Partial<OmitEB<entityType>>): string;
-    apiUpdateAllowed(item?: Partial<OmitEB<entityType>>): boolean;
-    readonly includedInApi: boolean;
+    displayValue(item: Partial<entityType>): string;
+    apiUpdateAllowed(item?: Partial<entityType>): boolean;
+    includedInApi(item?: Partial<entityType>): boolean;
     /** Adapts the value for usage with html input
      * @example
      * @Fields.dateOnly()

package/esm/src/column.d.ts

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