remult 0.17.3 → 0.18.0

package/esm/server/core.d.ts

@@ -1,2 +1,4 @@
 export { queuedJobInfo, QueueStorage, GenericRequest, GenericRequestHandler, GenericResponse, GenericRouter, createRemultServerCore, RemultServerOptions, SpecificRoute, RemultServer } from './expressBridge';
 export { JsonEntityFileStorage, JsonFileDataProvider } from './JsonEntityFileStorage';
+export { SseSubscriptionServer } from '../SseSubscriptionServer';
+export { DataProviderLiveQueryStorage } from '../live-query/data-provider-live-query-storage';

package/esm/server/core.js

@@ -1,2 +1,4 @@
 export { createRemultServerCore } from './expressBridge';
 export { JsonEntityFileStorage, JsonFileDataProvider } from './JsonEntityFileStorage';
+export { SseSubscriptionServer } from '../SseSubscriptionServer';
+export { DataProviderLiveQueryStorage } from '../live-query/data-provider-live-query-storage';

package/esm/server/expressBridge.d.ts

@@ -4,6 +4,7 @@ import { Remult, UserInfo } from '../src/context';
 import { ClassType } from '../classType';
 import { Repository } from '../src/remult3';
 import { IdEntity } from '../src/id-entity';
+import { LiveQueryStorage, SubscriptionServer } from '../src/live-query/SubscriptionServer';
 export interface RemultServerOptions<RequestType extends GenericRequest> {
     /** Sets a database connection for Remult.
      *
@@ -11,8 +12,20 @@ export interface RemultServerOptions<RequestType extends GenericRequest> {
     */
     dataProvider?: DataProvider | Promise<DataProvider> | (() => Promise<DataProvider | undefined>);
     queueStorage?: QueueStorage;
-    initRequest?: (remult: Remult, origReq: RequestType) => Promise<void>;
-    getUser?: (request: RequestType) => Promise<UserInfo>;
+    liveQueryStorage?: LiveQueryStorage;
+    subscriptionServer?: SubscriptionServer;
+    initRequest?: (request: RequestType, options: InitRequestOptions) => Promise<void>;
+    requestSerializer?: {
+        toJson: (request: RequestType) => any;
+        fromJson: (request: any) => RequestType;
+    };
+    /** Will create tables and columns in supporting databases. default: true
+     *
+     * @description
+     * when set to true, it'll create entities that do not exist, and add columns that are missing.
+    */
+    ensureSchema?: boolean;
+    getUser?: (request: RequestType) => Promise<UserInfo | undefined>;
     initApi?: (remult: Remult) => void | Promise<void>;
     logApiEndPoints?: boolean;
     defaultGetLimit?: number;
@@ -20,6 +33,10 @@ export interface RemultServerOptions<RequestType extends GenericRequest> {
     controllers?: ClassType<any>[];
     rootPath?: string;
 }
+export interface InitRequestOptions {
+    liveQueryStorage: LiveQueryStorage;
+    readonly remult: Remult;
+}
 export declare function createRemultServerCore<RequestType extends GenericRequest = GenericRequest>(options?: RemultServerOptions<RequestType>): RemultServer;
 export declare type GenericRequestHandler = (req: GenericRequest, res: GenericResponse, next: VoidFunction) => void;
 export interface ServerHandleResponse {
@@ -73,11 +90,6 @@ export interface queuedJobInfo {
     setResult(result: any): void;
     setProgress(progress: number): void;
 }
-export interface ApiActionResponse {
-    error(error: any): void;
-    success(result: any): void;
-    progress(progress: number): void;
-}
 export interface QueueStorage {
     createJob(url: string, userId: string): Promise<string>;
     getJobInfo(queuedJobId: string): Promise<queuedJobInfo>;

package/esm/server/expressBridge.js

@@ -5,11 +5,18 @@ import { allEntities, Remult } from '../src/context';
 import { Entity, Fields, getEntityKey } from '../src/remult3';
 import { IdEntity } from '../src/id-entity';
 import { remult } from '../src/remult-proxy';
+import { LiveQueryPublisher, InMemoryLiveQueryStorage } from '../src/live-query/SubscriptionServer';
+import { liveQueryKeepAliveRoute, streamUrl } from '../src/live-query/SubscriptionChannel';
+import { initDataProvider } from './initDataProvider';
+import { SseSubscriptionServer } from "../SseSubscriptionServer";
 ;
 export function createRemultServerCore(options) {
     if (!options) {
         options = {};
     }
+    if (!options.subscriptionServer) {
+        options.subscriptionServer = new SseSubscriptionServer();
+    }
     if (options.logApiEndPoints === undefined)
         options.logApiEndPoints = true;
     actionInfo.runningOnServer = true;
@@ -19,29 +26,59 @@ export function createRemultServerCore(options) {
     if (!options.queueStorage) {
         options.queueStorage = new InMemoryQueueStorage();
     }
-    let dataProvider;
-    if (typeof options.dataProvider === "function") {
-        dataProvider = options.dataProvider();
-    }
-    else
-        dataProvider = Promise.resolve(options.dataProvider);
-    dataProvider = dataProvider.then(async (dp) => {
-        if (dp)
-            return dp;
-        return new (await import('./JsonEntityFileStorage')).JsonFileDataProvider('./db');
-    });
+    let dataProvider = initDataProvider(options.dataProvider);
+    if (options.ensureSchema === undefined)
+        options.ensureSchema = true;
     RemultAsyncLocalStorage.enable();
-    if (options.initApi) {
-        dataProvider = dataProvider.then(async (dp) => {
-            var remult = new Remult(dp);
-            await new Promise((res) => {
-                RemultAsyncLocalStorage.instance.run(remult, async () => {
+    dataProvider = dataProvider.then(async (dp) => {
+        var remult = new Remult(dp);
+        await new Promise((res) => {
+            RemultAsyncLocalStorage.instance.run(remult, async () => {
+                if (options.ensureSchema) {
+                    let started = false;
+                    const startConsoleLog = () => {
+                        if (started)
+                            return;
+                        started = true;
+                        console.time("Ensure Schema");
+                    };
+                    if (dp.ensureSchema) {
+                        startConsoleLog();
+                        const entitiesMetadata = options.entities.map(e => remult.repo(e).metadata);
+                        await dp.ensureSchema(entitiesMetadata);
+                    }
+                    for (const item of [options.liveQueryStorage, options.queueStorage]) {
+                        if (item?.ensureSchema) {
+                            startConsoleLog();
+                            await item.ensureSchema();
+                        }
+                    }
+                    if (started)
+                        console.timeEnd("Ensure Schema");
+                }
+                if (options.initApi)
                     await options.initApi(remult);
-                    res({});
-                });
+                res({});
             });
-            return dp;
         });
+        return dp;
+    });
+    if (!options.requestSerializer) {
+        options.requestSerializer = {
+            toJson: x => {
+                const r = {
+                    url: x.url
+                };
+                for (const key of ['session', 'auth', 'user']) {
+                    if (x[key])
+                        r[key] = x[key];
+                }
+                return r;
+            },
+            fromJson: x => {
+                return x;
+            }
+        };
     }
     {
         let allControllers = [];
@@ -90,25 +127,50 @@ export class RemultAsyncLocalStorage {
     }
 }
 RemultAsyncLocalStorage.instance = new RemultAsyncLocalStorage(undefined);
-class RemultServerImplementation {
+/* @internal*/
+export class RemultServerImplementation {
     constructor(queue, options, dataProvider) {
         this.queue = queue;
         this.options = options;
         this.dataProvider = dataProvider;
+        this.liveQueryStorage = new InMemoryLiveQueryStorage();
+        this.runWithRequest = async (req, entityKey, what) => {
+            for (const e of this.options.entities) {
+                let key = getEntityKey(e);
+                if (key === entityKey) {
+                    await new Promise((result) => {
+                        this.withRemult(this.options.requestSerializer.fromJson(req), undefined, async () => {
+                            await what(remult.repo(e));
+                            result({});
+                        });
+                    });
+                    return;
+                }
+            }
+            throw new Error("Couldn't find entity " + entityKey);
+        };
         this.registeredRouter = false;
         this.hasQueue = false;
         /* internal */
         this.backendMethodsOpenApi = [];
+        if (options.liveQueryStorage)
+            this.liveQueryStorage = options.liveQueryStorage;
+        if (options.subscriptionServer)
+            this.subscriptionServer = options.subscriptionServer;
     }
+    ;
     withRemult(req, res, next) {
         this.process(async () => { next(); })(req, res);
     }
-    handle(req, gRes) {
+    getRouteImpl() {
         if (!this.routeImpl) {
             this.routeImpl = new RouteImplementation();
             this.registerRouter(this.routeImpl);
         }
-        return this.routeImpl.handle(req, gRes);
+        return this.routeImpl;
+    }
+    handle(req, gRes) {
+        return this.getRouteImpl().handle(req, gRes);
     }
     registerRouter(r) {
         if (this.registeredRouter)
@@ -144,6 +206,21 @@ class RemultServerImplementation {
                     },
                     doWork: undefined
                 }, r);
+            if (this.options.subscriptionServer instanceof SseSubscriptionServer) {
+                const streamPath = this.options.rootPath + '/' + streamUrl;
+                r.route(streamPath).get(this.process(async (remult, req, res, origReq, origRes) => {
+                    remult.subscriptionServer.openHttpServerStream(origReq, origRes);
+                }));
+                r.route(streamPath + '/subscribe').post(this.process(async (remult, req, res, origReq, origRes) => {
+                    remult.subscriptionServer.subscribeToChannel(origReq.body, res, remult);
+                }));
+                r.route(streamPath + '/unsubscribe').post(this.process(async (remult, req, res, origReq, origRes) => {
+                    remult.subscriptionServer.subscribeToChannel(origReq.body, res, remult, true);
+                }));
+            }
+            r.route(this.options.rootPath + '/' + liveQueryKeepAliveRoute).post(this.process(async (remult, req, res, origReq, origRes) => {
+                res.success(await remult.liveQueryStorage.keepAliveAndReturnUnknownQueryIds(origReq.body));
+            }));
         }
         this.options.entities.forEach(e => {
             let key = getEntityKey(e);
@@ -156,11 +233,11 @@ class RemultServerImplementation {
     add(key, dataApiFactory, r) {
         let myRoute = this.options.rootPath + '/' + key;
         if (this.options.logApiEndPoints)
-            console.log("[remult] " + myRoute);
+            console.info("[remult] " + myRoute);
         r.route(myRoute)
-            .get(this.process((c, req, res) => dataApiFactory(c).httpGet(res, req))).put(this.process(async (c, req, res, orig) => dataApiFactory(c).put(res, '', orig.body)))
+            .get(this.process((c, req, res, orig) => dataApiFactory(c).httpGet(res, req, () => this.options.requestSerializer.toJson(orig)))).put(this.process(async (c, req, res, orig) => dataApiFactory(c).put(res, '', orig.body)))
             .delete(this.process(async (c, req, res, orig) => dataApiFactory(c).delete(res, '')))
-            .post(this.process(async (c, req, res, orig) => dataApiFactory(c).httpPost(res, req, orig.body)));
+            .post(this.process(async (c, req, res, orig) => dataApiFactory(c).httpPost(res, req, orig.body, () => this.options.requestSerializer.toJson(orig))));
         r.route(myRoute + '/:id')
             //@ts-ignore
             .get(this.process(async (c, req, res, orig) => dataApiFactory(c).get(res, orig.params.id)))
@@ -170,11 +247,14 @@ class RemultServerImplementation {
             .delete(this.process(async (c, req, res, orig) => dataApiFactory(c).delete(res, orig.params.id)));
     }
     process(what) {
-        return async (req, res) => {
+        return async (req, origRes) => {
             let myReq = new ExpressRequestBridgeToDataApiRequest(req);
-            let myRes = new ExpressResponseBridgeToDataApiResponse(res, req);
+            let myRes = new ExpressResponseBridgeToDataApiResponse(origRes, req);
             let remult = new Remult();
+            remult.liveQueryPublisher = new LiveQueryPublisher(() => remult.subscriptionServer, () => remult.liveQueryStorage, this.runWithRequest);
             remult.dataProvider = (await this.dataProvider);
+            remult.subscriptionServer = this.subscriptionServer;
+            remult.liveQueryStorage = this.liveQueryStorage;
             await new Promise(res => {
                 RemultAsyncLocalStorage.instance.run(remult, async () => {
                     if (req) {
@@ -190,9 +270,17 @@ class RemultServerImplementation {
                             remult.user = (user);
                     }
                     if (this.options.initRequest) {
-                        await this.options.initRequest(remult, req);
+                        await this.options.initRequest(req, {
+                            remult,
+                            get liveQueryStorage() {
+                                return remult.liveQueryStorage;
+                            },
+                            set liveQueryStorage(value) {
+                                remult.liveQueryStorage = value;
+                            }
+                        });
                     }
-                    await what(remult, myReq, myRes, req);
+                    await what(remult, myReq, myRes, req, origRes);
                     res({});
                 });
             });
@@ -218,7 +306,7 @@ class RemultServerImplementation {
             })();
             this.backendMethodsOpenApi.push({ path: myUrl, allowed, tag });
             if (this.options.logApiEndPoints)
-                console.log("[remult] " + myUrl);
+                console.info("[remult] " + myUrl);
             if (queue) {
                 this.hasQueue = true;
                 this.queue.mapQueuedAction(myUrl, what);
@@ -582,7 +670,11 @@ class inProcessQueueHandler {
         this.actions.get(url)(body, req, {
             error: error => job.setErrorResult(serializeError(error)),
             success: result => job.setResult(result),
-            progress: progress => job.setProgress(progress)
+            progress: progress => job.setProgress(progress),
+            created: () => { throw Error("Created response not expected for queue"); },
+            deleted: () => { throw Error("deleted response not expected for queue"); },
+            notFound: () => { throw Error("notFound response not expected for queue"); },
+            forbidden: () => job.setErrorResult("Forbidden")
         });
         return id;
     }
@@ -720,6 +812,18 @@ class RouteImplementation {
                 constructor() {
                     this.statusCode = 200;
                 }
+                write(data) {
+                    gRes.write(data);
+                }
+                writeHead(statusCode, headers) {
+                    gRes.writeHead(statusCode, headers);
+                    this.statusCode = statusCode;
+                    res({ statusCode });
+                }
+                flush() {
+                    if (gRes.flush)
+                        gRes.flush();
+                }
                 json(data) {
                     if (gRes !== undefined)
                         gRes.json(data);

package/esm/server/index.d.ts

@@ -1,4 +1,5 @@
 import { GenericRequest, RemultServer, RemultServerOptions } from './expressBridge';
-export { queuedJobInfo, QueueStorage, GenericRequest, GenericRequestHandler, GenericResponse, GenericRouter, RemultServerOptions, SpecificRoute, RemultServer } from './expressBridge';
+export { queuedJobInfo, QueueStorage, GenericRequest, GenericRequestHandler, GenericResponse, GenericRouter, RemultServerOptions, SpecificRoute, RemultServer, InitRequestOptions } from './expressBridge';
 export { JsonEntityFileStorage, JsonFileDataProvider } from './JsonEntityFileStorage';
+export { DataProviderLiveQueryStorage } from '../live-query/data-provider-live-query-storage';
 export declare function createRemultServer<RequestType extends GenericRequest = GenericRequest>(options?: RemultServerOptions<RequestType>): RemultServer;

package/esm/server/index.js

@@ -1,6 +1,7 @@
-import { createRemultServerCore } from './expressBridge';
+import { createRemultServerCore, } from './expressBridge';
 import { initAsyncHooks } from './initAsyncHooks';
 export { JsonEntityFileStorage, JsonFileDataProvider } from './JsonEntityFileStorage';
+export { DataProviderLiveQueryStorage } from '../live-query/data-provider-live-query-storage';
 export function createRemultServer(options) {
     initAsyncHooks();
     return createRemultServerCore(options);

package/esm/server/initDataProvider.d.ts

@@ -0,0 +1,2 @@
+import { DataProvider } from '../src/data-interfaces';
+export declare function initDataProvider(optionsDataProvider?: DataProvider | Promise<DataProvider> | (() => Promise<DataProvider | undefined>)): Promise<DataProvider>;

package/esm/server/initDataProvider.js

@@ -0,0 +1,14 @@
+export function initDataProvider(optionsDataProvider) {
+    let dataProvider;
+    if (typeof optionsDataProvider === "function") {
+        dataProvider = optionsDataProvider();
+    }
+    else
+        dataProvider = Promise.resolve(optionsDataProvider);
+    dataProvider = dataProvider.then(async (dp) => {
+        if (dp)
+            return dp;
+        return new (await import('./JsonEntityFileStorage')).JsonFileDataProvider('./db');
+    });
+    return dataProvider;
+}

package/esm/src/buildRestDataProvider.d.ts

@@ -0,0 +1,31 @@
+import { RestDataProviderHttpProvider } from "./data-interfaces";
+import { RestDataProviderHttpProviderUsingFetch } from './data-providers/rest-data-provider';
+export declare function buildRestDataProvider(provider: ExternalHttpProvider | typeof fetch): RestDataProviderHttpProviderUsingFetch | RestDataProviderHttpProvider;
+export declare function isExternalHttpProvider(item: any): boolean;
+export declare class HttpProviderBridgeToRestDataProviderHttpProvider implements RestDataProviderHttpProvider {
+    private http;
+    constructor(http: ExternalHttpProvider);
+    post(url: string, data: any): Promise<any>;
+    delete(url: string): Promise<void>;
+    put(url: string, data: any): Promise<any>;
+    get(url: string): Promise<any>;
+}
+export declare function retry<T>(what: () => Promise<T>): Promise<T>;
+export declare function toPromise<T>(p: Promise<T> | {
+    toPromise(): Promise<T>;
+}): Promise<any>;
+export declare function processHttpException(ex: any): Promise<any>;
+export interface ExternalHttpProvider {
+    post(url: string, data: any): Promise<any> | {
+        toPromise(): Promise<any>;
+    };
+    delete(url: string): Promise<void> | {
+        toPromise(): Promise<void>;
+    };
+    put(url: string, data: any): Promise<any> | {
+        toPromise(): Promise<any>;
+    };
+    get(url: string): Promise<any> | {
+        toPromise(): Promise<any>;
+    };
+}

package/esm/src/buildRestDataProvider.js

@@ -0,0 +1,110 @@
+import { RestDataProviderHttpProviderUsingFetch } from './data-providers/rest-data-provider';
+export function buildRestDataProvider(provider) {
+    if (!provider)
+        return new RestDataProviderHttpProviderUsingFetch();
+    let httpDataProvider;
+    if (!httpDataProvider) {
+        if (isExternalHttpProvider(provider)) {
+            httpDataProvider = new HttpProviderBridgeToRestDataProviderHttpProvider(provider);
+        }
+    }
+    if (!httpDataProvider) {
+        if (typeof provider === "function") {
+            httpDataProvider = new RestDataProviderHttpProviderUsingFetch(provider);
+        }
+    }
+    return httpDataProvider;
+}
+export function isExternalHttpProvider(item) {
+    let http = item;
+    if (http && http.get && http.put && http.post && http.delete)
+        return true;
+    return false;
+}
+export class HttpProviderBridgeToRestDataProviderHttpProvider {
+    constructor(http) {
+        this.http = http;
+    }
+    async post(url, data) {
+        return await retry(() => toPromise(this.http.post(url, data)));
+    }
+    delete(url) {
+        return toPromise(this.http.delete(url));
+    }
+    put(url, data) {
+        return toPromise(this.http.put(url, data));
+    }
+    async get(url) {
+        return await retry(() => toPromise(this.http.get(url)));
+    }
+}
+export async function retry(what) {
+    while (true) {
+        try {
+            return await what();
+        }
+        catch (err) {
+            if (err.message?.startsWith("Error occurred while trying to proxy") ||
+                err.message?.startsWith("Error occured while trying to proxy") ||
+                err.message?.includes("http proxy error") ||
+                err.message?.startsWith("Gateway Timeout")) {
+                await new Promise((res, req) => {
+                    setTimeout(() => {
+                        res({});
+                    }, 250);
+                });
+                continue;
+            }
+            throw err;
+        }
+    }
+}
+export function toPromise(p) {
+    let r;
+    if (p["toPromise"] !== undefined) {
+        r = p["toPromise"]();
+    }
+    //@ts-ignore
+    else
+        r = p;
+    return r.then((x) => {
+        if (x && (x.status == 200 || x.status == 201) && x.headers && x.request && x.data) //for axios
+            return x.data;
+        return x;
+    }).catch(async (ex) => {
+        throw await processHttpException(ex);
+    });
+}
+export async function processHttpException(ex) {
+    let z = await ex;
+    var error;
+    if (z.error)
+        error = z.error;
+    else if (z.isAxiosError) {
+        if (typeof z.response?.data === "string")
+            error = z.response.data;
+        else
+            error = z?.response?.data;
+    }
+    if (!error)
+        error = z.message;
+    if (z.status == 0 && z.error.isTrusted)
+        error = "Network Error";
+    if (typeof error === 'string') {
+        error = {
+            message: error,
+        };
+    }
+    if (z.modelState)
+        error.modelState = z.modelState;
+    let httpStatusCode = z.status;
+    if (httpStatusCode === undefined)
+        httpStatusCode = z.response?.status;
+    if (httpStatusCode !== undefined && httpStatusCode !== null) {
+        error.httpStatusCode = httpStatusCode;
+    }
+    var result = Object.assign(error, {
+    //     exception: ex disabled for now because JSON.stringify crashed with this
+    });
+    return result;
+}

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

@@ -2,7 +2,10 @@ import { ClassType } from '../classType';
 import { Allowed, AllowedForInstance } from './context';
 import { EntityMetadata, FieldRef } from './remult3';
 export interface FieldOptions<entityType = any, valueType = any> {
-    /**A human readable name for the field */
+    /** A human readable name for the field. Can be used to achieve a consistent caption for a field throughout the app
+    * @example
+    * <input placeholder={taskRepo.metadata.fields.title.caption}/>
+    */
     caption?: string;
     /** If it can store null in the database */
     allowNull?: boolean;
@@ -32,14 +35,23 @@ export interface FieldOptions<entityType = any, valueType = any> {
      *   }
      * })
      */
-    validate?: ((entity: entityType, col: FieldRef<entityType, valueType>) => (any | Promise<any>)) | ((entity: entityType, col: FieldRef<entityType, valueType>) => (any | Promise<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, col: FieldRef<entityType, valueType>) => (any | Promise<any>));
+    saving?: ((entity: entityType, fieldRef: FieldRef<entityType, valueType>) => (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. */
     dbName?: string;
-    /** Used or fields that are based on an sql expressions, instead of a physical table column */
+    /** Used or fields that are based on an sql expressions, instead of a physical table column
+     * @example
+     *
+     * @Fields.integer({
+     *   sqlExpression:e=> 'length(title)'
+     * })
+     * titleLength = 0;
+     * @Fields.string()
+     * title='';
+    */
     sqlExpression?: string | ((entity: EntityMetadata<entityType>) => string | Promise<string>);
     /** For fields that shouldn't be part of an update or insert statement */
     dbReadOnly?: boolean;
@@ -62,18 +74,42 @@ export interface FieldOptions<entityType = any, valueType = any> {
     /** The key to be used for this field */
     key?: string;
 }
+/**Metadata for a `Field`, this metadata can be used in the user interface to provide a richer UI experience */
 export interface FieldMetadata<valueType = any> {
+    /** The field's member name in an object.
+     * @example
+     * const taskRepo = remult.repo(Task);
+     * console.log(taskRepo.metadata.fields.title.key);
+     * // result: title
+     */
     readonly key: string;
-    readonly target: ClassType<valueType>;
-    readonly valueType: any;
+    /** A human readable caption for the field. Can be used to achieve a consistent caption for a field throughout the app
+     * @example
+     * <input placeholder={taskRepo.metadata.fields.title.caption}/>
+     */
     readonly caption: string;
+    /** The field's value type (number,string etc...) */
+    readonly valueType: any;
+    /** The options sent to this field's decorator */
+    readonly options: FieldOptions;
+    /** The `inputType` relevant for this field, determined by the options sent to it's decorator and the valueConverter in these options */
     readonly inputType: string;
+    /** if null is allowed for this field */
     readonly allowNull: boolean;
+    /** The class that contains this field
+     * @example
+     * const taskRepo = remult.repo(Task);
+     * Task == taskRepo.metadata.fields.title.target //will return true
+    */
+    readonly target: ClassType<valueType>;
+    /** Returns the dbName - based on it's `dbName` option and it's `sqlExpression` option */
     getDbName(): Promise<string>;
+    /** Indicates if this field is based on a server express */
     readonly isServerExpression: boolean;
+    /** indicates that this field should only be included in select statement, and excluded from update or insert. useful for db generated ids etc... */
     readonly dbReadOnly: boolean;
+    /** the Value converter for this field */
     readonly valueConverter: ValueConverter<valueType>;
-    readonly options: FieldOptions;
 }
 export interface ValueConverter<valueType> {
     fromJson?(val: any): valueType;
@@ -86,7 +122,7 @@ export interface ValueConverter<valueType> {
     readonly fieldTypeInDb?: string;
     readonly inputType?: string;
 }
-export declare type FieldValidator<entityType = any, valueType = any> = (entity: entityType, col: FieldRef<entityType, valueType>) => void | Promise<void>;
+export declare type FieldValidator<entityType = any, valueType = any> = (entity: entityType, fieldRef: FieldRef<entityType, valueType>) => void | Promise<void>;
 export declare type ValueOrExpression<valueType> = valueType | (() => valueType);
 export declare function valueOrExpressionToValue<valueType>(f: ValueOrExpression<valueType>): valueType;
 export interface ValueListItem {

package/esm/src/column.d.ts

@@ -1,7 +1,7 @@
 import { ClassType } from '../classType';
 import { FieldMetadata, FieldOptions, ValueConverter } from './column-interfaces';
 import { Filter } from './filter/filter-interfaces';
-import { EntityFilter, FindOptions, Repository, RepositoryImplementation } from './remult3';
+import { EntityFilter, FindOptions, idType, Repository, RepositoryImplementation } from './remult3';
 export declare function makeTitle(name: string): string;
 export declare class CompoundIdField implements FieldMetadata<string> {
     fields: FieldMetadata[];
@@ -25,12 +25,12 @@ export declare class CompoundIdField implements FieldMetadata<string> {
 }
 export declare class LookupColumn<T> {
     private repository;
-    id: string;
+    id: idType<T>;
     setId(val: any): void;
     waitLoadOf(id: any): Promise<T>;
     get(id: any): any;
     set(item: T): void;
-    constructor(repository: RepositoryImplementation<T>, id: string);
+    constructor(repository: RepositoryImplementation<T>, id: idType<T>);
     get item(): T;
     waitLoad(): Promise<T>;
 }