remult 0.19.2 → 0.20.0-exp.1

package/esm/graphql.d.ts

@@ -1,5 +1,5 @@
 import { RemultServer } from "./server/expressBridge";
-export declare function remultGraphql(api: RemultServer): {
+export declare function remultGraphql(api: RemultServer<any>): {
     rootValue: {};
     schema: string;
 };

package/esm/remult-express.d.ts

@@ -3,4 +3,4 @@ import { RemultServer, RemultServerOptions } from './server/expressBridge';
 export declare function remultExpress(options?: RemultServerOptions<express.Request> & {
     bodyParser?: boolean;
     bodySizeLimit?: string;
-}): express.RequestHandler & RemultServer;
+}): express.RequestHandler & RemultServer<express.Request>;

package/esm/remult-express.js

@@ -12,7 +12,9 @@ export function remultExpress(options) {
         app.use(express.json({ limit: options.bodySizeLimit }));
         app.use(express.urlencoded({ extended: true, limit: options.bodySizeLimit }));
     }
-    const server = createRemultServer(options);
+    const server = createRemultServer(options, {
+        buildGenericRequest: req => req
+    });
     server.registerRouter(app);
     return Object.assign(app, {
         getRemult: (req) => server.getRemult(req),

package/esm/remult-fastify.d.ts

@@ -1,3 +1,3 @@
 import type { FastifyPluginCallback, FastifyRequest } from 'fastify';
 import { RemultServer, RemultServerOptions } from './server/expressBridge';
-export declare function remultFastify(options: RemultServerOptions<FastifyRequest>): FastifyPluginCallback & RemultServer;
+export declare function remultFastify(options: RemultServerOptions<FastifyRequest>): FastifyPluginCallback & RemultServer<FastifyRequest>;

package/esm/remult-fastify.js

@@ -29,7 +29,9 @@ export function remultFastify(options) {
         };
         return response;
     }
-    const api = createRemultServer(options);
+    const api = createRemultServer(options, {
+        buildGenericRequest: req => req
+    });
     const pluginFunction = async (instance, op) => {
         //@ts-ignore
         let fastifyRouter = {

package/esm/remult-fresh.d.ts

@@ -1,8 +1,8 @@
-import { RemultServerOptions, GenericRequest } from "./server/expressBridge";
+import { RemultServerOptions } from "./server/expressBridge";
 import { Remult } from "./src/context";
-export declare function remultFresh<RequestType extends GenericRequest>(options: RemultServerOptions<RequestType>, response: FreshResponse): RemultFresh;
+export declare function remultFresh(options: RemultServerOptions<FreshRequest>, response: FreshResponse): RemultFresh;
 export interface RemultFresh {
-    getRemult(req: GenericRequest): Promise<Remult>;
+    getRemult(req: FreshRequest): Promise<Remult>;
     openApiDoc(options: {
         title: string;
     }): any;

package/esm/remult-fresh.js

@@ -1,6 +1,8 @@
 import { createRemultServerCore } from "./server/expressBridge";
 export function remultFresh(options, response) {
-    const server = createRemultServerCore(options);
+    const server = createRemultServerCore(options, {
+        buildGenericRequest: r => r
+    });
     return {
         getRemult: r => server.getRemult(r),
         openApiDoc: x => server.openApiDoc(x),
@@ -17,7 +19,7 @@ export function remultFresh(options, response) {
                     break;
             }
             let init = {};
-            const res = await server.handle(theReq);
+            const res = await server.handle(req);
             if (res) {
                 init.status = res.statusCode;
                 if (res.data) {

package/esm/remult-next.d.ts

@@ -2,7 +2,7 @@
 import type { GetServerSideProps, NextApiRequest, PreviewData, NextApiHandler } from "next";
 import type { ParsedUrlQuery } from "querystring";
 import { RemultServer, RemultServerOptions } from "./server";
-export declare function remultNext(options?: RemultServerOptions<NextApiRequest>): RemultServer & NextApiHandler & {
+export declare function remultNext(options?: RemultServerOptions<NextApiRequest>): RemultServer<NextApiRequest> & NextApiHandler & {
     getServerSideProps<P extends {
         [key: string]: any;
     } = {

package/esm/remult-next.js

@@ -1,6 +1,8 @@
 import { createRemultServer } from "./server";
 export function remultNext(options) {
-    let result = createRemultServer(options);
+    let result = createRemultServer(options, {
+        buildGenericRequest: req => req
+    });
     return Object.assign((req, res) => result.handle(req, res), result, {
         getRemult: (...args) => result.getRemult(...args),
         handle: (...args) => result.handle(...args),

package/esm/remult-svletekit.d.ts

@@ -0,0 +1,3 @@
+import type { RequestEvent, Handle } from '@sveltejs/kit';
+import { RemultServer, RemultServerOptions } from './server';
+export declare function remultSveltekit(options?: RemultServerOptions<RequestEvent>): RemultServer<RequestEvent> & Handle;

package/esm/remult-svletekit.js

@@ -0,0 +1,83 @@
+import { createRemultServer } from './server';
+export function remultSveltekit(options) {
+    let result = createRemultServer(options, {
+        buildGenericRequest: event => ({
+            url: event.request.url,
+            method: event.request.method,
+            body: event.locals["_tempJson"],
+            on: (e, do1) => {
+                if (e === 'close') {
+                    event.locals["_tempOnClose"] = do1;
+                }
+            }
+        })
+    });
+    const handler = async ({ event, resolve }) => {
+        if (event.url.pathname.startsWith(options.rootPath)) {
+            let json = {};
+            try {
+                if (event.request.method == 'POST' || event.request.method == 'PUT') {
+                    json = await event.request.json();
+                }
+            }
+            catch (error) {
+                console.log(error);
+            }
+            let sseResponse = undefined;
+            event.locals["_tempOnClose"] = () => { };
+            const response = {
+                end: () => { },
+                json: () => { },
+                status: () => {
+                    return response;
+                },
+                write: () => { },
+                writeHead: (status, headers) => {
+                    if (status === 200 && headers) {
+                        const contentType = headers['Content-Type'];
+                        if (contentType === 'text/event-stream') {
+                            const messages = [];
+                            response.write = (x) => messages.push(x);
+                            const stream = new ReadableStream({
+                                start: (controller) => {
+                                    for (const message of messages) {
+                                        controller.enqueue(message);
+                                    }
+                                    response.write = (data) => {
+                                        controller.enqueue(data);
+                                    };
+                                },
+                                cancel: () => {
+                                    response.write = () => { };
+                                    event.locals["_tempOnClose"]();
+                                }
+                            });
+                            sseResponse = new Response(stream, { headers });
+                        }
+                    }
+                }
+            };
+            event.locals["_tempJson"] = json;
+            const responseFromRemultHandler = await result.handle(event, response);
+            if (sseResponse !== undefined) {
+                return sseResponse;
+            }
+            if (responseFromRemultHandler) {
+                return new Response(JSON.stringify(responseFromRemultHandler.data), {
+                    status: responseFromRemultHandler.statusCode
+                });
+            }
+        }
+        return new Promise((res) => {
+            result.withRemult(event, undefined, async () => {
+                res(await resolve(event));
+            });
+        });
+    };
+    return Object.assign(handler, {
+        getRemult: (req) => result.getRemult(req),
+        openApiDoc: (options) => result.openApiDoc(options),
+        registerRouter: x => result.registerRouter(x),
+        withRemult: (...args) => result.withRemult(...args)
+    });
+}

package/esm/server/expressBridge.d.ts

@@ -5,7 +5,7 @@ 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> {
+export interface RemultServerOptions<RequestType> {
     /**Entities to use for the api */
     entities?: ClassType<any>[];
     /**Controller to use for the api */
@@ -41,10 +41,10 @@ export interface RemultServerOptions<RequestType extends GenericRequest> {
     subscriptionServer?: SubscriptionServer;
     /** A storage to use to store live queries, relevant mostly for serverless scenarios or larger scales */
     liveQueryStorage?: LiveQueryStorage;
-    /** Used to store the relevent request info for re running a live query */
-    requestSerializer?: {
-        toJson: (request: RequestType) => any;
-        fromJson: (request: any) => RequestType;
+    /** Used to store the context relevant info for re running a live query */
+    contextSerializer?: {
+        serialize(remult: Remult): Promise<any>;
+        deserialize(json: any, remult: Remult): Promise<void>;
     };
     /** Storage to use for backend methods that use queue */
     queueStorage?: QueueStorage;
@@ -53,21 +53,21 @@ export interface InitRequestOptions {
     liveQueryStorage: LiveQueryStorage;
     readonly remult: Remult;
 }
-export declare function createRemultServerCore<RequestType extends GenericRequest = GenericRequest>(options?: RemultServerOptions<RequestType>): RemultServer;
+export declare function createRemultServerCore<RequestType>(options: RemultServerOptions<RequestType>, serverCoreOptions: ServerCoreOptions<RequestType>): RemultServer<RequestType>;
 export declare type GenericRequestHandler = (req: GenericRequest, res: GenericResponse, next: VoidFunction) => void;
 export interface ServerHandleResponse {
     data?: any;
     statusCode: number;
 }
-export interface RemultServer {
-    getRemult(req: GenericRequest): Promise<Remult>;
+export interface RemultServer<RequestType> {
+    getRemult(req: RequestType): Promise<Remult>;
     openApiDoc(options: {
         title: string;
         version?: string;
     }): any;
     registerRouter(r: GenericRouter): void;
-    handle(req: GenericRequest, gRes?: GenericResponse): Promise<ServerHandleResponse | undefined>;
-    withRemult(req: GenericRequest, res: GenericResponse, next: VoidFunction): any;
+    handle(req: RequestType, gRes?: GenericResponse): Promise<ServerHandleResponse | undefined>;
+    withRemult(req: RequestType, res: GenericResponse, next: VoidFunction): any;
 }
 export declare type GenericRouter = {
     route(path: string): SpecificRoute;
@@ -128,3 +128,6 @@ export declare class JobsInQueueEntity extends IdEntity {
     error: boolean;
     progress: number;
 }
+export interface ServerCoreOptions<RequestType> {
+    buildGenericRequest(req: RequestType): GenericRequest;
+}

package/esm/server/expressBridge.js

@@ -10,7 +10,7 @@ import { liveQueryKeepAliveRoute, streamUrl } from '../src/live-query/Subscripti
 import { initDataProvider } from './initDataProvider';
 import { SseSubscriptionServer } from "../SseSubscriptionServer";
 ;
-export function createRemultServerCore(options) {
+export function createRemultServerCore(options, serverCoreOptions) {
     if (!options) {
         options = {};
     }
@@ -63,23 +63,6 @@ export function createRemultServerCore(options) {
         });
         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 = [];
         if (!options.entities)
@@ -93,7 +76,7 @@ export function createRemultServerCore(options) {
     if (options.rootPath === undefined)
         options.rootPath = '/api';
     actionInfo.runningOnServer = true;
-    let bridge = new RemultServerImplementation(new inProcessQueueHandler(options.queueStorage), options, dataProvider);
+    let bridge = new RemultServerImplementation(new inProcessQueueHandler(options.queueStorage), options, dataProvider, serverCoreOptions);
     return bridge;
 }
 ;
@@ -129,20 +112,22 @@ export class RemultAsyncLocalStorage {
 RemultAsyncLocalStorage.instance = new RemultAsyncLocalStorage(undefined);
 /* @internal*/
 export class RemultServerImplementation {
-    constructor(queue, options, dataProvider) {
+    constructor(queue, options, dataProvider, coreOptions) {
         this.queue = queue;
         this.options = options;
         this.dataProvider = dataProvider;
+        this.coreOptions = coreOptions;
         this.liveQueryStorage = new InMemoryLiveQueryStorage();
-        this.runWithRequest = async (req, entityKey, what) => {
+        this.runWithSerializedJsonContextData = async (jsonContextData, 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({});
-                        });
+                    await this.runWithRemult(async (remult) => {
+                        remult.user = jsonContextData.user;
+                        if (this.options.contextSerializer) {
+                            await this.options.contextSerializer.deserialize(jsonContextData, remult);
+                        }
+                        await what(remult.repo(e));
                     });
                     return;
                 }
@@ -164,7 +149,7 @@ export class RemultServerImplementation {
     }
     getRouteImpl() {
         if (!this.routeImpl) {
-            this.routeImpl = new RouteImplementation();
+            this.routeImpl = new RouteImplementation(this.coreOptions);
             this.registerRouter(this.routeImpl);
         }
         return this.routeImpl;
@@ -230,14 +215,24 @@ export class RemultServerImplementation {
                 }, r);
         });
     }
+    async serializeContext(remult) {
+        let result = {
+            user: remult.user,
+            context: undefined
+        };
+        if (this.options.contextSerializer) {
+            result.context = await this.options.contextSerializer.serialize(remult);
+        }
+        return result;
+    }
     add(key, dataApiFactory, r) {
         let myRoute = this.options.rootPath + '/' + key;
         if (this.options.logApiEndPoints)
             console.info("[remult] " + myRoute);
         r.route(myRoute)
-            .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)))
+            .get(this.process((c, req, res, orig) => dataApiFactory(c).httpGet(res, req, () => this.serializeContext(c)))).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, () => this.options.requestSerializer.toJson(orig))));
+            .post(this.process(async (c, req, res, orig) => dataApiFactory(c).httpPost(res, req, orig.body, () => this.serializeContext(c))));
         r.route(myRoute + '/:id')
             //@ts-ignore
             .get(this.process(async (c, req, res, orig) => dataApiFactory(c).get(res, orig.params.id)))
@@ -246,29 +241,38 @@ export class RemultServerImplementation {
             //@ts-ignore
             .delete(this.process(async (c, req, res, orig) => dataApiFactory(c).delete(res, orig.params.id)));
     }
+    async runWithRemult(what) {
+        let remult = new Remult();
+        remult.liveQueryPublisher = new LiveQueryPublisher(() => remult.subscriptionServer, () => remult.liveQueryStorage, this.runWithSerializedJsonContextData);
+        remult.dataProvider = (await this.dataProvider);
+        remult.subscriptionServer = this.subscriptionServer;
+        remult.liveQueryStorage = this.liveQueryStorage;
+        await new Promise(res => {
+            RemultAsyncLocalStorage.instance.run(remult, async () => {
+                res(await what(remult));
+            });
+        });
+    }
     process(what) {
         return async (req, origRes) => {
             let myReq = new ExpressRequestBridgeToDataApiRequest(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) {
-                        let user;
-                        if (this.options.getUser)
-                            user = await this.options.getUser(req);
-                        else {
-                            user = req['user'];
-                            if (!user)
-                                user = req['auth'];
-                        }
-                        if (user)
-                            remult.user = (user);
+            await this.runWithRemult(async (remult) => {
+                remult.liveQueryPublisher = new LiveQueryPublisher(() => remult.subscriptionServer, () => remult.liveQueryStorage, this.runWithSerializedJsonContextData);
+                remult.dataProvider = (await this.dataProvider);
+                remult.subscriptionServer = this.subscriptionServer;
+                remult.liveQueryStorage = this.liveQueryStorage;
+                if (req) {
+                    let user;
+                    if (this.options.getUser)
+                        user = await this.options.getUser(req);
+                    else {
+                        user = req['user'];
+                        if (!user)
+                            user = req['auth'];
                     }
+                    if (user)
+                        remult.user = (user);
                     if (this.options.initRequest) {
                         await this.options.initRequest(req, {
                             remult,
@@ -280,9 +284,8 @@ export class RemultServerImplementation {
                             }
                         });
                     }
-                    await what(remult, myReq, myRes, req, origRes);
-                    res({});
-                });
+                }
+                await what(remult, myReq, myRes, req, origRes);
             });
         };
     }
@@ -776,7 +779,8 @@ export class EntityQueueStorage {
     }
 }
 class RouteImplementation {
-    constructor() {
+    constructor(coreOptions) {
+        this.coreOptions = coreOptions;
         this.map = new Map();
     }
     route(path) {
@@ -846,7 +850,8 @@ class RouteImplementation {
             this.middleware(req, response, () => res(undefined));
         });
     }
-    middleware(req, res, next) {
+    middleware(origReq, res, next) {
+        const req = this.coreOptions.buildGenericRequest(origReq);
         let theUrl = req.url;
         if (theUrl.startsWith('/')) //next sends a partial url '/api/tasks' and not the full url
             theUrl = 'http://stam' + theUrl;

package/esm/server/index.d.ts

@@ -1,6 +1,6 @@
-import { GenericRequest, RemultServer, RemultServerOptions } from './expressBridge';
+import { RemultServer, RemultServerOptions, ServerCoreOptions } 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 { SseSubscriptionServer } from '../SseSubscriptionServer';
-export declare function createRemultServer<RequestType extends GenericRequest = GenericRequest>(options?: RemultServerOptions<RequestType>): RemultServer;
+export declare function createRemultServer<RequestType>(options: RemultServerOptions<RequestType>, serverCoreOptions?: ServerCoreOptions<RequestType>): RemultServer<RequestType>;

package/esm/server/index.js

@@ -3,7 +3,7 @@ import { initAsyncHooks } from './initAsyncHooks';
 export { JsonEntityFileStorage, JsonFileDataProvider } from './JsonEntityFileStorage';
 export { DataProviderLiveQueryStorage } from '../live-query/data-provider-live-query-storage';
 export { SseSubscriptionServer } from '../SseSubscriptionServer';
-export function createRemultServer(options) {
+export function createRemultServer(options, serverCoreOptions) {
     initAsyncHooks();
-    return createRemultServerCore(options);
+    return createRemultServerCore(options, serverCoreOptions || { buildGenericRequest: req => req });
 }

package/esm/src/data-api.d.ts

@@ -5,8 +5,8 @@ export declare class DataApi<T = any> {
     private repository;
     private remult;
     constructor(repository: Repository<T>, remult: Remult);
-    httpGet(res: DataApiResponse, req: DataApiRequest, serializeRequest: () => any): Promise<void>;
-    httpPost(res: DataApiResponse, req: DataApiRequest, body: any, serializeRequest: () => any): Promise<void>;
+    httpGet(res: DataApiResponse, req: DataApiRequest, serializeRequest: () => Promise<any>): Promise<void>;
+    httpPost(res: DataApiResponse, req: DataApiRequest, body: any, serializeRequest: () => Promise<any>): Promise<void>;
     static defaultGetLimit: number;
     get(response: DataApiResponse, id: any): Promise<void>;
     count(response: DataApiResponse, request: DataApiRequest, filterBody?: any): Promise<void>;

package/esm/src/live-query/SubscriptionServer.js

@@ -1,10 +1,10 @@
 import { findOptionsFromJson } from '../data-providers/rest-data-provider';
 /* @internal*/
 export class LiveQueryPublisher {
-    constructor(subscriptionServer, liveQueryStorage, performWithRequest) {
+    constructor(subscriptionServer, liveQueryStorage, performWithContext) {
         this.subscriptionServer = subscriptionServer;
         this.liveQueryStorage = liveQueryStorage;
-        this.performWithRequest = performWithRequest;
+        this.performWithContext = performWithContext;
         this.debugFileSaver = (x) => { };
     }
     runPromise(p) { }
@@ -12,7 +12,7 @@ export class LiveQueryPublisher {
         //TODO 2 - optimize so that the user will get their messages first. Based on user id
         await (this.liveQueryStorage().forEach(entityKey, async ({ query: q, setData }) => {
             let query = { ...q.data };
-            await this.performWithRequest(query.requestJson, entityKey, async (repo) => {
+            await this.performWithContext(query.requestJson, entityKey, async (repo) => {
                 const messages = [];
                 const currentItems = await repo.find(findOptionsFromJson(query.findOptionsJson, repo.metadata));
                 const currentIds = currentItems.map(x => repo.getEntityRef(x).getId());

package/esm/src/remult3/RepositoryImplementation.js

@@ -1259,7 +1259,7 @@ export class columnDefsImpl {
     get includedInApi() {
         if (this.options.includeInApi === undefined)
             return true;
-        return this.remult.isAllowed(this.options.includeInApi); //TODO - consolidate other code paths to go through here
+        return this.remult.isAllowed(this.options.includeInApi); //TODO 2- consolidate other code paths to go through here
     }
     toInput(value, inputType) {
         return this.valueConverter.toInput(value, inputType);
@@ -1711,10 +1711,7 @@ export function decorateColumnSettings(settings, remult) {
     if (settings.valueType == String) {
         let x = settings;
         if (!settings.valueConverter)
-            x.valueConverter = {
-                toJson: x => x,
-                fromJson: x => x
-            };
+            x.valueConverter = ValueConverters.String;
     }
     if (settings.valueType == Number) {
         let x = settings;

package/esm/src/shared-tests/db-tests.db-tests.js

@@ -25,6 +25,14 @@ testAll("what", async ({ remult, createEntity }) => {
     await (await createEntity(stam)).create({ id: 1, title: 'noam' }).save();
     expect(await remult.repo(stam).count()).toBe(1);
 }, false);
+testAll("data types", async ({ remult, createEntity }) => {
+    let r = await (await createEntity(stam)).create({
+        id: 1,
+        //@ts-ignore
+        title: 42
+    }).save();
+    expect(r.title).toEqual("42");
+}, false);
 testAll("filter works on all db", async ({ createEntity }) => {
     let s = await entityWithValidations.create4RowsInDp(createEntity);
     expect((await s.find({ where: { myId: [1, 3] } })).length).toBe(2);

package/esm/src/tests/testHelper.spec.js

@@ -186,7 +186,7 @@ export function createMockHttpDataProvider(dataApi) {
             r.success = data => { result = data; };
             try {
                 testConfiguration.restDbRunningOnServer = true;
-                await dataApi.httpGet(r, urlToReq(url), () => "");
+                await dataApi.httpGet(r, urlToReq(url), async () => "");
             }
             finally {
                 testConfiguration.restDbRunningOnServer = false;
@@ -200,7 +200,7 @@ export function createMockHttpDataProvider(dataApi) {
             r.success = data => { result = data; };
             try {
                 testConfiguration.restDbRunningOnServer = true;
-                await dataApi.httpPost(r, urlToReq(url), data, () => ({}));
+                await dataApi.httpPost(r, urlToReq(url), data, async () => ({}));
             }
             finally {
                 testConfiguration.restDbRunningOnServer = false;

package/esm/src/valueConverters.d.ts

@@ -5,6 +5,7 @@ export declare class ValueConverters {
     static readonly DateOnlyString: ValueConverter<Date>;
     static readonly Boolean: ValueConverter<Boolean>;
     static readonly Number: ValueConverter<number>;
+    static readonly String: ValueConverter<String>;
     static readonly Integer: ValueConverter<number>;
     static readonly Default: Required<ValueConverter<any>>;
     static readonly JsonString: ValueConverter<any>;

package/esm/src/valueConverters.js

@@ -141,6 +141,14 @@ ValueConverters.Number = {
     },
     inputType: InputTypes.number
 };
+ValueConverters.String = {
+    fromDb: enforceString,
+    toDb: enforceString,
+    fromJson: enforceString,
+    toJson: enforceString,
+    fromInput: enforceString,
+    toInput: enforceString,
+};
 ValueConverters.Integer = {
     ...ValueConverters.Number,
     toJson: value => {
@@ -180,3 +188,10 @@ ValueConverters.JsonValue = {
     toInput: x => ValueConverters.JsonString.toJson(x),
     fieldTypeInDb: 'json'
 };
+function enforceString(value) {
+    if (value === null || value === undefined)
+        return value;
+    if (typeof (value) !== "string")
+        return value.toString();
+    return value;
+}

package/graphql.d.ts

@@ -1,5 +1,5 @@
 import { RemultServer } from "./server/expressBridge";
-export declare function remultGraphql(api: RemultServer): {
+export declare function remultGraphql(api: RemultServer<any>): {
     rootValue: {};
     schema: string;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "remult",
-    "version": "0.19.2",
+    "version": "0.20.0-exp.1",
     "description": "A CRUD framework for full-stack TypeScript",
     "main": "index.js",
     "types": "index.d.ts",
@@ -78,6 +78,14 @@
             },
             "import": "./esm/remult-fresh.js"
         },
+        "./remult-sveltekit": {
+            "require": "./remult-sveltekit.js",
+            "node": {
+                "require": "./remult-sveltekit.js",
+                "import": "./remult-sveltekit.js"
+            },
+            "import": "./esm/remult-sveltekit.js"
+        },
         "./postgres": {
             "require": "./postgres/index.js",
             "node": {

package/remult-express.d.ts

@@ -3,4 +3,4 @@ import { RemultServer, RemultServerOptions } from './server/expressBridge';
 export declare function remultExpress(options?: RemultServerOptions<express.Request> & {
     bodyParser?: boolean;
     bodySizeLimit?: string;
-}): express.RequestHandler & RemultServer;
+}): express.RequestHandler & RemultServer<express.Request>;

package/remult-express.js

@@ -16,7 +16,9 @@ function remultExpress(options) {
         app.use(express.json({ limit: options.bodySizeLimit }));
         app.use(express.urlencoded({ extended: true, limit: options.bodySizeLimit }));
     }
-    var server = index_1.createRemultServer(options);
+    var server = index_1.createRemultServer(options, {
+        buildGenericRequest: function (req) { return req; }
+    });
     server.registerRouter(app);
     return Object.assign(app, {
         getRemult: function (req) { return server.getRemult(req); },

package/remult-fastify.d.ts

@@ -1,3 +1,3 @@
 import type { FastifyPluginCallback, FastifyRequest } from 'fastify';
 import { RemultServer, RemultServerOptions } from './server/expressBridge';
-export declare function remultFastify(options: RemultServerOptions<FastifyRequest>): FastifyPluginCallback & RemultServer;
+export declare function remultFastify(options: RemultServerOptions<FastifyRequest>): FastifyPluginCallback & RemultServer<FastifyRequest>;