remult 0.23.4 → 0.24.0-exp.1

package/SseSubscriptionServer.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
-import type { GenericResponse } from './server/index';
-import type { Remult } from './src/context';
-import type { SubscriptionServer } from './src/live-query/SubscriptionServer';
+import type { GenericResponse } from './server/index.js';
+import type { Remult } from './src/context.js';
+import type { SubscriptionServer } from './src/live-query/SubscriptionServer.js';
 export declare class SseSubscriptionServer implements SubscriptionServer {
     private canUserConnectToChannel?;
     constructor(canUserConnectToChannel?: (channel: string, remult: Remult) => boolean);

package/SseSubscriptionServer.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.clientConnection = exports.SseSubscriptionServer = void 0;
 var tslib_1 = require("tslib");
 var uuid_1 = require("uuid");
-var SseSubscriptionClient_1 = require("./src/live-query/SseSubscriptionClient");
+var SseSubscriptionClient_js_1 = require("./src/live-query/SseSubscriptionClient.js");
 var SseSubscriptionServer = /** @class */ (function () {
     function SseSubscriptionServer(canUserConnectToChannel) {
         this.canUserConnectToChannel = canUserConnectToChannel;
@@ -50,7 +50,7 @@ var SseSubscriptionServer = /** @class */ (function () {
             }
             finally { if (e_1) throw e_1.error; }
         }
-        res.success(SseSubscriptionClient_1.ConnectionNotFoundError);
+        res.success(SseSubscriptionClient_js_1.ConnectionNotFoundError);
     };
     SseSubscriptionServer.prototype.publishMessage = function (channel, message) {
         return tslib_1.__awaiter(this, void 0, void 0, function () {

package/ably.d.ts

@@ -1,6 +1,6 @@
-import type * as Ably from '../../node_modules/ably';
-import type { SubscriptionClient, SubscriptionClientConnection } from './src/live-query/SubscriptionChannel';
-import type { SubscriptionServer } from './src/live-query/SubscriptionServer';
+import type * as Ably from 'ably/ably';
+import type { SubscriptionClient, SubscriptionClientConnection } from './src/live-query/SubscriptionChannel.js';
+import type { SubscriptionServer } from './src/live-query/SubscriptionServer.js';
 export declare class AblySubscriptionClient implements SubscriptionClient {
     private ably;
     constructor(ably: Ably.Types.RealtimePromise);

package/esm/SseSubscriptionServer.js

@@ -1,5 +1,5 @@
 import { v4 as uuid } from 'uuid';
-import { ConnectionNotFoundError } from './src/live-query/SseSubscriptionClient';
+import { ConnectionNotFoundError } from './src/live-query/SseSubscriptionClient.js';
 export class SseSubscriptionServer {
     canUserConnectToChannel;
     //@internal

package/esm/graphql.js

@@ -1,6 +1,6 @@
-import { getRelationInfo } from './internals';
-import { Remult, remult } from './index';
-import { DataApi } from './src/data-api';
+import { getRelationInfo } from './internals.js';
+import { Remult, remult } from './index.js';
+import { DataApi } from './src/data-api.js';
 const v2ConnectionAndPagination = false;
 const andImplementation = false;
 let _removeComments = false;

package/esm/index.js

@@ -1,29 +1,29 @@
-export { 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, Relations, } 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
-export { WebSqlDataProvider } from './src/data-providers/web-sql-data-provider'; //V
-export { SqlDatabase } from './src/data-providers/sql-database'; //V
-export { CustomSqlFilterBuilder, dbNamesOf, } from './src/filter/filter-consumer-bridge-to-sql-request';
-export { JsonDataProvider, } from './src/data-providers/json-data-provider'; //V
+export { EntityBase, ControllerBase, FieldType, getFields, ValueListFieldType, getValueList, ValueListInfo, CaptionTransformer, } from './src/remult3/RepositoryImplementation.js';
+export { Entity } from './src/remult3/entity.js';
+export { getEntityRef } from './src/remult3/getEntityRef.js';
+export { Field, Fields, Relations, } from './src/remult3/Fields.js';
+export { IdEntity } from './src/remult3/IdEntity.js';
+export { describeClass } from './src/remult3/DecoratorReplacer.js';
+export { RestDataProvider } from './src/data-providers/rest-data-provider.js'; //V
+export { InMemoryDataProvider } from './src/data-providers/in-memory-database.js'; //V
+export { WebSqlDataProvider } from './src/data-providers/web-sql-data-provider.js'; //V
+export { SqlDatabase } from './src/data-providers/sql-database.js'; //V
+export { CustomSqlFilterBuilder, dbNamesOf, } from './src/filter/filter-consumer-bridge-to-sql-request.js';
+export { JsonDataProvider, } from './src/data-providers/json-data-provider.js'; //V
 //export * from './src/data-api'; //reconsider if to make internal
-export { Controller, BackendMethod, ProgressListener, } from './src/server-action';
-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 { UrlBuilder } from './urlBuilder';
-export { Validators } from './src/validators';
-export { ValueConverters } from './src/valueConverters';
-export { remult } from './src/remult-proxy';
-import { remult } from './src/remult-proxy';
+export { Controller, BackendMethod, ProgressListener, } from './src/server-action.js';
+export { Allow, Remult, withRemult, isBackend, EventSource, } from './src/context.js';
+export { Sort } from './src/sort.js';
+export { CompoundIdField } from './src/CompoundIdField.js';
+export { Filter, } from './src/filter/filter-interfaces.js';
+export { UrlBuilder } from './urlBuilder.js';
+export { Validators } from './src/validators.js';
+export { ValueConverters } from './src/valueConverters.js';
+export { remult } from './src/remult-proxy.js';
+import { remult } from './src/remult-proxy.js';
 //export { getId } from './src/remult3/getId';
-export { InMemoryLiveQueryStorage, } from './src/live-query/SubscriptionServer';
-export { SubscriptionChannel, } from './src/live-query/SubscriptionChannel';
+export { InMemoryLiveQueryStorage, } from './src/live-query/SubscriptionServer.js';
+export { SubscriptionChannel, } from './src/live-query/SubscriptionChannel.js';
 /**
  * A convenient shortcut function to quickly obtain a repository for a specific entity type in Remult.
  *

package/esm/internals.js

@@ -1,5 +1,5 @@
-export { getRelationInfo } from './src/remult3/relationInfoMember';
-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 { getRelationInfo } from './src/remult3/relationInfoMember.js';
+export { decorateColumnSettings, controllerRefImpl, getControllerRef, } from './src/remult3/RepositoryImplementation.js';
+export { getEntitySettings } from './src/remult3/getEntityRef.js';
+export { __updateEntityBasedOnWhere } from './src/filter/filter-interfaces.js';
+export { actionInfo } from './src/server-action-info.js';

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

@@ -1,9 +1,9 @@
 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 { Entity } from '../src/remult3/entity';
+import { initDataProvider } from '../server/initDataProvider.js';
+import { allEntities, Remult } from '../src/context.js';
+import { EntityBase } from '../src/remult3/RepositoryImplementation.js';
+import { Fields } from '../src/remult3/Fields.js';
+import { Entity } from '../src/remult3/entity.js';
 export class DataProviderLiveQueryStorage {
     repo;
     dataProvider;

package/esm/package.json

@@ -0,0 +1,3 @@
+{
+    "type": "module"
+}

package/esm/postgres/index.d.ts

@@ -1,2 +1,2 @@
-export * from './postgres-data-provider';
-export * from './schema-builder';
+export { PostgresDataProvider, PostgresPool, preparePostgresQueueStorage, PostgresClient, createPostgresConnection, createPostgresDataProvider, PostgresCommandSource, } from './postgres-data-provider';
+export { PostgresSchemaBuilder, postgresColumnSyntax } from './schema-builder';

package/esm/postgres/index.js

@@ -1,2 +1,2 @@
-export * from './postgres-data-provider';
-export * from './schema-builder';
+export { PostgresDataProvider, preparePostgresQueueStorage, createPostgresConnection, createPostgresDataProvider, } from './postgres-data-provider.js';
+export { PostgresSchemaBuilder, postgresColumnSyntax, } from './schema-builder.js';

package/esm/postgres/postgres-data-provider.d.ts

@@ -11,26 +11,37 @@ export interface PostgresClient extends PostgresCommandSource {
 }
 export declare class PostgresDataProvider implements SqlImplementation {
     private pool;
+    private options?;
     supportsJsonColumnType: boolean;
     static getDb(remult?: Remult): ClientBase;
     entityIsUsedForTheFirstTime(entity: EntityMetadata): Promise<void>;
     getLimitSqlSyntax(limit: number, offset: number): string;
     createCommand(): SqlCommand;
-    constructor(pool: PostgresPool);
+    constructor(pool: PostgresPool, options?: {
+        wrapIdentifier?: (name: string) => string;
+        schema?: string;
+    });
+    wrapIdentifier: (name: any) => any;
     ensureSchema(entities: EntityMetadata<any>[]): Promise<void>;
     transaction(action: (dataProvider: SqlImplementation) => Promise<void>): Promise<void>;
 }
 export interface PostgresCommandSource {
     query(queryText: string, values?: any[]): Promise<QueryResult>;
 }
-export declare function createPostgresConnection(options?: {
-    connectionString?: string;
-    sslInDev?: boolean;
-    configuration?: 'heroku' | PoolConfig;
-}): Promise<SqlDatabase>;
+export declare function createPostgresConnection(options?: Parameters<typeof createPostgresDataProvider>[0]): Promise<SqlDatabase>;
 export declare function createPostgresDataProvider(options?: {
     connectionString?: string;
     sslInDev?: boolean;
     configuration?: 'heroku' | PoolConfig;
+    wrapIdentifier?: (name: string) => string;
+    caseInsensitiveIdentifiers?: boolean;
+    schema?: string;
 }): Promise<SqlDatabase>;
 export declare function preparePostgresQueueStorage(sql: SqlDatabase): Promise<import("../server/expressBridge").EntityQueueStorage>;
+export declare class PostgresSchemaWrapper implements PostgresPool {
+    private pool;
+    private schema;
+    constructor(pool: PostgresPool, schema: string);
+    connect(): Promise<PostgresClient>;
+    query(queryText: string, values?: any[]): Promise<QueryResult>;
+}

package/esm/postgres/postgres-data-provider.js

@@ -1,9 +1,11 @@
-import { Pool } from 'pg';
-import { Remult } from '../src/context';
-import { SqlDatabase } from '../src/data-providers/sql-database';
-import { PostgresSchemaBuilder } from './schema-builder';
+import pg from 'pg';
+const { Pool } = pg;
+import { Remult } from '../src/context.js';
+import { SqlDatabase } from '../src/data-providers/sql-database.js';
+import { PostgresSchemaBuilder } from './schema-builder.js';
 export class PostgresDataProvider {
     pool;
+    options;
     supportsJsonColumnType = true;
     static getDb(remult) {
         const sql = SqlDatabase.getDb(remult);
@@ -20,12 +22,22 @@ export class PostgresDataProvider {
     createCommand() {
         return new PostgresBridgeToSQLCommand(this.pool);
     }
-    constructor(pool) {
+    constructor(pool, options) {
         this.pool = pool;
+        this.options = options;
+        if (options.wrapIdentifier)
+            this.wrapIdentifier = options.wrapIdentifier;
+        if (options.schema) {
+            this.pool = new PostgresSchemaWrapper(pool, options.schema);
+        }
     }
+    wrapIdentifier = (name) => name
+        .split('.')
+        .map((name) => name.startsWith('"') ? name : '"' + name.replace(/"/g, '""') + '"')
+        .join('.');
     async ensureSchema(entities) {
         var db = new SqlDatabase(this);
-        var sb = new PostgresSchemaBuilder(db);
+        var sb = new PostgresSchemaBuilder(db, this.options?.schema);
         await sb.ensureSchema(entities);
     }
     async transaction(action) {
@@ -42,6 +54,7 @@ export class PostgresDataProvider {
                 supportsJsonColumnType: this.supportsJsonColumnType,
                 //@ts-ignore
                 pool: client,
+                wrapIdentifier: this.wrapIdentifier,
             });
             await client.query('COMMIT');
         }
@@ -66,7 +79,7 @@ class PostgresBridgeToSQLCommand {
         this.values.push(val);
         return '$' + this.values.length;
     }
-    execute(sql) {
+    async execute(sql) {
         return this.source
             .query(sql, this.values)
             .then((r) => new PostgresBridgeToSQLQueryResult(r));
@@ -110,7 +123,11 @@ export async function createPostgresDataProvider(options) {
     if (!config.connectionString && options.connectionString) {
         config.connectionString = options.connectionString;
     }
-    const db = new SqlDatabase(new PostgresDataProvider(new Pool(config)));
+    const db = new SqlDatabase(new PostgresDataProvider(new Pool(config), {
+        wrapIdentifier: options?.wrapIdentifier ||
+            (options.caseInsensitiveIdentifiers && ((name) => name)),
+        schema: options.schema,
+    }));
     let remult = new Remult();
     remult.dataProvider = db;
     return db;
@@ -118,9 +135,31 @@ export async function createPostgresDataProvider(options) {
 export async function preparePostgresQueueStorage(sql) {
     let c = new Remult();
     c.dataProvider = sql;
-    let JobsInQueueEntity = (await import('../server/expressBridge'))
+    let JobsInQueueEntity = (await import('../server/expressBridge.js'))
         .JobsInQueueEntity;
     let e = c.repo(JobsInQueueEntity);
     await sql.ensureSchema([e.metadata]);
-    return new (await import('../server/expressBridge')).EntityQueueStorage(c.repo(JobsInQueueEntity));
+    return new (await import('../server/expressBridge.js')).EntityQueueStorage(c.repo(JobsInQueueEntity));
+}
+export class PostgresSchemaWrapper {
+    pool;
+    schema;
+    constructor(pool, schema) {
+        this.pool = pool;
+        this.schema = schema;
+    }
+    async connect() {
+        let r = await this.pool.connect();
+        await r.query('set search_path to ' + this.schema);
+        return r;
+    }
+    async query(queryText, values) {
+        let c = await this.connect();
+        try {
+            return await c.query(queryText, values);
+        }
+        finally {
+            c.release();
+        }
+    }
 }

package/esm/postgres/schema-builder.js

@@ -1,8 +1,8 @@
-import { allEntities } from '../src/context';
-import { dbNamesOf, isDbReadonly, } from '../src/filter/filter-consumer-bridge-to-sql-request';
-import { remult as defaultRemult } from '../src/remult-proxy';
-import { isAutoIncrement } from '../src/remult3/RepositoryImplementation';
-import { ValueConverters } from '../src/valueConverters';
+import { allEntities } from '../src/context.js';
+import { dbNamesOf, isDbReadonly, } from '../src/filter/filter-consumer-bridge-to-sql-request.js';
+import { remult as defaultRemult } from '../src/remult-proxy.js';
+import { isAutoIncrement } from '../src/remult3/RepositoryImplementation.js';
+import { ValueConverters } from '../src/valueConverters.js';
 export function postgresColumnSyntax(x, dbName) {
     let result = dbName;
     if (x.valueType == Number) {
@@ -97,7 +97,7 @@ export class PostgresSchemaBuilder {
         const entities = [];
         for (const entityClass of [...allEntities].reverse()) {
             let entity = remult.repo(entityClass).metadata;
-            let e = await dbNamesOf(entity);
+            let e = await dbNamesOf(entity, this.pool.wrapIdentifier);
             if (completed.has(e.$entityName))
                 continue;
             completed.add(e.$entityName);
@@ -107,7 +107,7 @@ export class PostgresSchemaBuilder {
     }
     async ensureSchema(entities) {
         for (const entity of entities) {
-            let e = await dbNamesOf(entity);
+            let e = await dbNamesOf(entity, this.pool.wrapIdentifier);
             try {
                 if (!entity.options.sqlExpression) {
                     if (e.$entityName.toLowerCase().indexOf('from ') < 0) {
@@ -124,7 +124,7 @@ export class PostgresSchemaBuilder {
     }
     async createIfNotExist(entity) {
         var c = this.pool.createCommand();
-        let e = await dbNamesOf(entity);
+        let e = await dbNamesOf(entity, this.pool.wrapIdentifier);
         await c
             .execute(`SELECT 1 FROM information_Schema.tables WHERE ` +
             `${this.whereTableAndSchema(c, e)}`)
@@ -154,7 +154,7 @@ CREATE table ${this.schemaAndName(e)} (${result}\r\n)`;
         });
     }
     async addColumnIfNotExist(entity, c) {
-        let e = await dbNamesOf(entity);
+        let e = await dbNamesOf(entity, this.pool.wrapIdentifier);
         if (isDbReadonly(c(entity), e))
             return;
         try {
@@ -177,7 +177,7 @@ CREATE table ${this.schemaAndName(e)} (${result}\r\n)`;
     async verifyAllColumns(entity) {
         try {
             let cmd = this.pool.createCommand();
-            let e = await dbNamesOf(entity);
+            let e = await dbNamesOf(entity, this.pool.wrapIdentifier);
             let cols = (await cmd.execute(`SELECT column_name FROM information_schema.columns WHERE ` +
                 `${this.whereTableAndSchema(cmd, e)}`)).rows.map((x) => x.column_name.toLocaleLowerCase());
             for (const col of entity.fields) {

package/esm/remult-express.js

@@ -1,5 +1,5 @@
 import * as express from 'express';
-import { createRemultServer } from './server/index';
+import { createRemultServer } from './server/index.js';
 export function remultExpress(options) {
     let app = express.Router();
     if (!options) {
@@ -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),
-        // [ ] V1.5 add with remult promise
+        withRemultAsync: (req, what) => server.withRemultAsync(req, what),
     });
 }

package/esm/remult-fastify.js

@@ -1,4 +1,4 @@
-import { createRemultServer } from './server/index';
+import { createRemultServer } from './server/index.js';
 export function remultFastify(options) {
     function fastifyHandler(handler) {
         const response = (req, res) => {
@@ -63,6 +63,6 @@ export function remultFastify(options) {
     return Object.assign(pluginFunction, {
         getRemult: (x) => api.getRemult(x),
         openApiDoc: (x) => api.openApiDoc(x),
-        withRemult: (req, what) => api.withRemultPromise(req, what),
+        withRemult: (req, what) => api.withRemultAsync(req, what),
     });
 }

package/esm/remult-fresh.js

@@ -1,4 +1,4 @@
-import { createRemultServerCore } from './server/expressBridge';
+import { createRemultServerCore } from './server/expressBridge.js';
 export function remultFresh(options, response) {
     const server = createRemultServerCore(options, {
         buildGenericRequestInfo: (r) => r,

package/esm/remult-hapi.js

@@ -1,4 +1,4 @@
-import { createRemultServer, } from './server';
+import { createRemultServer, } from './server/index.js';
 import { PassThrough } from 'stream';
 export function remultHapi(options) {
     const api = createRemultServer(options, {
@@ -24,7 +24,6 @@ export function remultHapi(options) {
                         let r = {
                             status(statusCode) {
                                 status = statusCode;
-                                console.log(statusCode);
                                 return r;
                             },
                             end() {
@@ -107,6 +106,6 @@ export function remultHapi(options) {
     return Object.assign(routesPlugin, {
         getRemult: (x) => api.getRemult(x),
         openApiDoc: (x) => api.openApiDoc(x),
-        withRemult: (req, what) => api.withRemultPromise(req, what),
+        withRemult: (req, what) => api.withRemultAsync(req, what),
     });
 }

package/esm/remult-knex/index.js

@@ -1,13 +1,13 @@
-import { allEntities } from '../src/context';
-import { dbNamesOf, isDbReadonly, } from '../src/filter/filter-consumer-bridge-to-sql-request';
-import { customDatabaseFilterToken, Filter, } from '../src/filter/filter-interfaces';
-import { CompoundIdField } from '../src/CompoundIdField';
-import { remult as remultContext } from '../src/remult-proxy';
-import { getRepository, isAutoIncrement, } from '../src/remult3/RepositoryImplementation';
-import { Sort } from '../src/sort';
-import { ValueConverters } from '../src/valueConverters';
-import { resultCompoundIdFilter as resultCompoundIdFilter } from '../src/resultCompoundIdFilter';
-import { getRepositoryInternals } from '../src/remult3/repository-internals';
+import { allEntities } from '../src/context.js';
+import { dbNamesOf, isDbReadonly, } from '../src/filter/filter-consumer-bridge-to-sql-request.js';
+import { customDatabaseFilterToken, Filter, } from '../src/filter/filter-interfaces.js';
+import { CompoundIdField } from '../src/CompoundIdField.js';
+import { remult as remultContext } from '../src/remult-proxy.js';
+import { getRepository, isAutoIncrement, } from '../src/remult3/RepositoryImplementation.js';
+import { Sort } from '../src/sort.js';
+import { ValueConverters } from '../src/valueConverters.js';
+import { resultCompoundIdFilter as resultCompoundIdFilter } from '../src/resultCompoundIdFilter.js';
+import { getRepositoryInternals } from '../src/remult3/repository-internals.js';
 export class KnexDataProvider {
     knex;
     constructor(knex) {
@@ -139,7 +139,16 @@ class KnexEntityDataProvider {
         });
     }
     async init() {
-        return (await dbNamesOf(this.entity));
+        const r = (await dbNamesOf(this.entity));
+        return {
+            $dbNameOf: (f) => {
+                let fm = f;
+                if (fm.options.sqlExpression)
+                    return this.knex.raw(r.$dbNameOf(f));
+                return r.$dbNameOf(f);
+            },
+            $entityName: r.$entityName,
+        };
     }
     async update(id, data) {
         const e = await this.init();

package/esm/remult-mongo.js

@@ -1,10 +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';
+import { CompoundIdField, Filter } from './index.js';
+import { dbNamesOf } from './src/filter/filter-consumer-bridge-to-sql-request.js';
+import { remult as remultContext } from './src/remult-proxy.js';
+import { getRepository } from './src/remult3/RepositoryImplementation.js';
+import { resultCompoundIdFilter } from './src/resultCompoundIdFilter.js';
+import { getRepositoryInternals } from './src/remult3/repository-internals.js';
 export class MongoDataProvider {
     db;
     client;

package/esm/remult-next.js

@@ -1,4 +1,4 @@
-import { createRemultServer } from './server';
+import { createRemultServer } from './server/index.js';
 export function remultNext(options) {
     let result = createRemultServer(options, {
         buildGenericRequestInfo: (req) => req,
@@ -109,6 +109,6 @@ export function remultNextApp(options) {
         POST: handler,
         PUT: handler,
         DELETE: handler,
-        withRemult: (what) => result.withRemultPromise({}, what),
+        withRemult: (what) => result.withRemultAsync({}, what),
     };
 }

package/esm/remult-nuxt.js

@@ -0,0 +1,49 @@
+import { readBody } from 'h3';
+import { createRemultServer, } from './server/index.js';
+export function remultNuxt(options) {
+    const result = createRemultServer(options, {
+        buildGenericRequestInfo: (event) => {
+            return {
+                method: event.node.req.method,
+                url: event.node.req.url,
+                on: (a, b) => event.node.req.on('close', () => {
+                    b();
+                }),
+            };
+        },
+        getRequestBody: async (event) => await readBody(event),
+    });
+    const handler = async (event) => {
+        let sse = false;
+        const response = {
+            end: () => { },
+            json: () => { },
+            status: () => {
+                return response;
+            },
+            write: (what) => {
+                event.node.res.write(what);
+            },
+            writeHead: (status, headers) => {
+                sse = true;
+                event.node.res.writeHead(status, headers);
+            },
+        };
+        const r = await result.handle(event, response);
+        if (sse) {
+            await new Promise((resolve) => {
+                event.node.req.on('close', () => resolve({}));
+            });
+        }
+        if (r) {
+            return r.data;
+        }
+    };
+    return Object.assign(handler, {
+        getRemult: (req) => result.getRemult(req),
+        openApiDoc: (options) => result.openApiDoc(options),
+        withRemult(event, what) {
+            return result.withRemultAsync(event, what);
+        },
+    });
+}

package/esm/remult-sveltekit.js

@@ -1,4 +1,4 @@
-import { createRemultServer } from './server';
+import { createRemultServer } from './server/index.js';
 export function remultSveltekit(options) {
     let result = createRemultServer(options, {
         buildGenericRequestInfo: (event) => ({
@@ -68,7 +68,7 @@ export function remultSveltekit(options) {
         getRemult: (req) => result.getRemult(req),
         openApiDoc: (options) => result.openApiDoc(options),
         withRemult(request, what) {
-            return result.withRemultPromise(request, what);
+            return result.withRemultAsync(request, what);
         },
     });
 }

package/esm/server/JsonEntityFileStorage.js

@@ -1,6 +1,6 @@
 import * as fs from 'fs';
 import * as path from 'path';
-import { JsonDataProvider } from '../index';
+import { JsonDataProvider } from '../index.js';
 export class JsonEntityFileStorage {
     folderPath;
     getItem(entityDbName) {

package/esm/server/core.js

@@ -1,4 +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';
+export { createRemultServerCore, } from './expressBridge.js';
+export { JsonEntityFileStorage, JsonFileDataProvider, } from './JsonEntityFileStorage.js';
+export { SseSubscriptionServer } from '../SseSubscriptionServer.js';
+export { DataProviderLiveQueryStorage } from '../live-query/data-provider-live-query-storage.js';