remult 0.24.0-exp.5 → 0.24.1

package/esm/remult-nuxt.js

@@ -1,5 +1,5 @@
-import { readBody } from 'h3';
-import { createRemultServer, } from './server/index.js';
+import { readBody, setResponseStatus } from 'h3';
+import { createRemultServer } from './server/index.js';
 export function remultNuxt(options) {
     const result = createRemultServer(options, {
         buildGenericRequestInfo: (event) => {
@@ -36,14 +36,16 @@ export function remultNuxt(options) {
             });
         }
         if (r) {
+            if (r.statusCode !== 200)
+                setResponseStatus(event, r.statusCode);
             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);
+        withRemult(request, what) {
+            return result.withRemultAsync(request, what);
         },
     });
 }

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

@@ -21,11 +21,11 @@ class JsonEntityDataProvider {
     async loadEntityData(what) {
         let data = [];
         let dbName = await this.entity.options.dbName;
-        let s = this.helper.getItem(dbName);
+        let s = await this.helper.getItem(dbName);
         if (s)
             data = JSON.parse(s);
         let dp = new ArrayEntityDataProvider(this.entity, data);
-        return what(dp, () => this.helper.setItem(dbName, JSON.stringify(data, undefined, 2)));
+        return what(dp, async () => await this.helper.setItem(dbName, JSON.stringify(data, undefined, 2)));
     }
     p = Promise.resolve();
     find(options) {
@@ -35,20 +35,20 @@ class JsonEntityDataProvider {
         return (this.p = this.p.then(() => this.loadEntityData((dp, save) => dp.count(where))));
     }
     update(id, data) {
-        return (this.p = this.p.then(() => this.loadEntityData((dp, save) => dp.update(id, data).then((x) => {
-            save();
+        return (this.p = this.p.then(() => this.loadEntityData((dp, save) => dp.update(id, data).then(async (x) => {
+            await save();
             return x;
         }))));
     }
     delete(id) {
-        return (this.p = this.p.then(() => this.loadEntityData((dp, save) => dp.delete(id).then((x) => {
-            save();
+        return (this.p = this.p.then(() => this.loadEntityData((dp, save) => dp.delete(id).then(async (x) => {
+            await save();
             return x;
         }))));
     }
     async insert(data) {
-        return (this.p = this.p.then(() => this.loadEntityData((dp, save) => dp.insert(data).then((x) => {
-            save();
+        return (this.p = this.p.then(() => this.loadEntityData((dp, save) => dp.insert(data).then(async (x) => {
+            await save();
             return x;
         }))));
     }

package/esm/src/remult3/remult3.js

@@ -1,25 +1,12 @@
 export {};
-//p1 - V - sql-expression for knex
-//p1 - V - postgres case sensitive
-//p1 - V - filterToRaw should get a dbnames of - and we should create a dbnames of that supports an alias
-//p1 - V - fix sql log to console to make more sense
-//p1 - V - change wrap name to wrapIdentifier, case insensitive identifiers
-//p1 - v - add schema option to create postgres data provider
-/*p1 - V -  with remult async for remultexpress
-//y1 - lint tests (reference to js)
-//p1 - V Operator '>' cannot be applied to types 'Number' and 'number'.ts(2365) - change fields to <entityType,number> (now it's Number)
-//p1 - V Field(()=>String) - doesn't play nice with strict mode - it prevents people from extending basic types
-//p1 - V withRemult function Add a with remult to Remult! - there is an existing one called Remult.run
-//p1 - V -  dbname to metadata consider making dbname in the field metadata options - non optional, so it'll be clear that it always have value - something like require the specific key - or move it to the metadata field
-//p1 - V - getEntityRefClone  What I would like is to make a copy of the item (without getting it from the server again)
-//p1 - V find one i had a question about find first's different syntax from find that confused a user
-
-rename V - withremultpromise to that withRemultAsync
-expose live query storage in remult
-
-request optional - and depends on that run `getUser` & `initRequest`
-*/
+/*y1 - investigated sqlite in web, the chrome recommendation seemed hardly used -
+- https://developer.chrome.com/blog/sqlite-wasm-in-the-browser-backed-by-the-origin-private-file-system/
+- https://www.npmjs.com/package/@sqlite.org/sqlite-wasm
+ All I could find is correspondance around evolu :) the guy I met in prague last year
+ Indexed db was also annoying with it's upgrade process etc...
+ I'm OPFS & json for now.
 //y2 - from the crm-demo(https://crm-demo.up.railway.app/deals), after editing a deal: - _updateEntityBasedOnApi
+
 //y2 - Backend methods are transactions, it's not intuitive and maybe should be optional / opt in
 //y2 - how to run a transaction as a user
 //p1 - enum column

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "remult",
-    "version": "0.24.0-exp.5",
+    "version": "0.24.1",
     "description": "A CRUD framework for full-stack TypeScript",
     "homepage": "https://remult.dev",
     "repository": {

package/remult-nuxt.d.ts

@@ -1,5 +1,5 @@
 import type { H3Event } from 'h3';
-import { RemultServerCore, RemultServerOptions, RemultServer } from './server/index.js';
+import type { RemultServerCore, RemultServerOptions, RemultServer } from './server/index.js';
 export declare function remultNuxt(options: RemultServerOptions<H3Event>): RemultNuxtServer;
 export type RemultNuxtServer = RemultServerCore<H3Event> & ((event: H3Event) => Promise<any>) & {
     withRemult: RemultServer<H3Event>['withRemultAsync'];

package/remult-nuxt.js

@@ -57,6 +57,8 @@ function remultNuxt(options) {
                     _a.label = 3;
                 case 3:
                     if (r) {
+                        if (r.statusCode !== 200)
+                            (0, h3_1.setResponseStatus)(event, r.statusCode);
                         return [2 /*return*/, r.data];
                     }
                     return [2 /*return*/];
@@ -66,8 +68,8 @@ function remultNuxt(options) {
     return Object.assign(handler, {
         getRemult: function (req) { return result.getRemult(req); },
         openApiDoc: function (options) { return result.openApiDoc(options); },
-        withRemult: function (event, what) {
-            return result.withRemultAsync(event, what);
+        withRemult: function (request, what) {
+            return result.withRemultAsync(request, what);
         },
     });
 }

package/src/data-providers/json-data-provider.d.ts

@@ -1,8 +1,8 @@
 import type { DataProvider, EntityDataProvider } from '../data-interfaces.js';
 import type { EntityMetadata } from '../remult3/remult3.js';
 export interface JsonEntityStorage {
-    getItem(entityDbName: string): string | null;
-    setItem(entityDbName: string, json: string): any;
+    getItem(entityDbName: string): string | null | Promise<string | null>;
+    setItem(entityDbName: string, json: string): void | Promise<void>;
 }
 export declare class JsonDataProvider implements DataProvider {
     private storage;

package/src/data-providers/json-data-provider.js

@@ -42,13 +42,18 @@ var JsonEntityDataProvider = /** @class */ (function () {
                         return [4 /*yield*/, this.entity.options.dbName];
                     case 1:
                         dbName = _a.sent();
-                        s = this.helper.getItem(dbName);
+                        return [4 /*yield*/, this.helper.getItem(dbName)];
+                    case 2:
+                        s = _a.sent();
                         if (s)
                             data = JSON.parse(s);
                         dp = new array_entity_data_provider_js_1.ArrayEntityDataProvider(this.entity, data);
-                        return [2 /*return*/, what(dp, function () {
-                                return _this.helper.setItem(dbName, JSON.stringify(data, undefined, 2));
-                            })];
+                        return [2 /*return*/, what(dp, function () { return tslib_1.__awaiter(_this, void 0, void 0, function () { return tslib_1.__generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, this.helper.setItem(dbName, JSON.stringify(data, undefined, 2))];
+                                    case 1: return [2 /*return*/, _a.sent()];
+                                }
+                            }); }); })];
                 }
             });
         });
@@ -69,10 +74,16 @@ var JsonEntityDataProvider = /** @class */ (function () {
         var _this = this;
         return (this.p = this.p.then(function () {
             return _this.loadEntityData(function (dp, save) {
-                return dp.update(id, data).then(function (x) {
-                    save();
-                    return x;
-                });
+                return dp.update(id, data).then(function (x) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                    return tslib_1.__generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0: return [4 /*yield*/, save()];
+                            case 1:
+                                _a.sent();
+                                return [2 /*return*/, x];
+                        }
+                    });
+                }); });
             });
         }));
     };
@@ -80,10 +91,16 @@ var JsonEntityDataProvider = /** @class */ (function () {
         var _this = this;
         return (this.p = this.p.then(function () {
             return _this.loadEntityData(function (dp, save) {
-                return dp.delete(id).then(function (x) {
-                    save();
-                    return x;
-                });
+                return dp.delete(id).then(function (x) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                    return tslib_1.__generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0: return [4 /*yield*/, save()];
+                            case 1:
+                                _a.sent();
+                                return [2 /*return*/, x];
+                        }
+                    });
+                }); });
             });
         }));
     };
@@ -93,10 +110,16 @@ var JsonEntityDataProvider = /** @class */ (function () {
             return tslib_1.__generator(this, function (_a) {
                 return [2 /*return*/, (this.p = this.p.then(function () {
                         return _this.loadEntityData(function (dp, save) {
-                            return dp.insert(data).then(function (x) {
-                                save();
-                                return x;
-                            });
+                            return dp.insert(data).then(function (x) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                                return tslib_1.__generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0: return [4 /*yield*/, save()];
+                                        case 1:
+                                            _a.sent();
+                                            return [2 /*return*/, x];
+                                    }
+                                });
+                            }); });
                         });
                     }))];
             });

package/src/remult3/remult3.d.ts

@@ -588,26 +588,6 @@ export interface ClassDecoratorContextStub<Class extends new (...args: any) => a
     addInitializer(initializer: (this: Class) => void): void;
 }
 export type ClassFieldDecorator<entityType, valueType> = (target: any, context: string | ClassFieldDecoratorContextStub<entityType, valueType | undefined>, c?: any) => void;
-/**
- * //p2 - doc this
-remult.apiClient.httpClient = (
-  input: RequestInfo | URL,
-  init?: RequestInit
-  ) => {
-    return fetch(input, {
-      ...init,
-      headers: {
-        authorization: 'Bearer ' + sessionStorage.sessionId,
-      },
-      cache: 'no-store',
-    })
-}
-
-&&
-remult.apiClient.url='localhost:3007/api
-
-
-*/
 /**
 * our default is allow null false.
 * for sql databases we add a db default of 0/''/false

package/src/remult3/remult3.js

@@ -1,26 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//p1 - V - sql-expression for knex
-//p1 - V - postgres case sensitive
-//p1 - V - filterToRaw should get a dbnames of - and we should create a dbnames of that supports an alias
-//p1 - V - fix sql log to console to make more sense
-//p1 - V - change wrap name to wrapIdentifier, case insensitive identifiers
-//p1 - v - add schema option to create postgres data provider
-/*p1 - V -  with remult async for remultexpress
-//y1 - lint tests (reference to js)
-//p1 - V Operator '>' cannot be applied to types 'Number' and 'number'.ts(2365) - change fields to <entityType,number> (now it's Number)
-//p1 - V Field(()=>String) - doesn't play nice with strict mode - it prevents people from extending basic types
-//p1 - V withRemult function Add a with remult to Remult! - there is an existing one called Remult.run
-//p1 - V -  dbname to metadata consider making dbname in the field metadata options - non optional, so it'll be clear that it always have value - something like require the specific key - or move it to the metadata field
-//p1 - V - getEntityRefClone  What I would like is to make a copy of the item (without getting it from the server again)
-//p1 - V find one i had a question about find first's different syntax from find that confused a user
-
-rename V - withremultpromise to that withRemultAsync
-expose live query storage in remult
-
-request optional - and depends on that run `getUser` & `initRequest`
-*/
+/*y1 - investigated sqlite in web, the chrome recommendation seemed hardly used -
+- https://developer.chrome.com/blog/sqlite-wasm-in-the-browser-backed-by-the-origin-private-file-system/
+- https://www.npmjs.com/package/@sqlite.org/sqlite-wasm
+ All I could find is correspondance around evolu :) the guy I met in prague last year
+ Indexed db was also annoying with it's upgrade process etc...
+ I'm OPFS & json for now.
 //y2 - from the crm-demo(https://crm-demo.up.railway.app/deals), after editing a deal: - _updateEntityBasedOnApi
+
 //y2 - Backend methods are transactions, it's not intuitive and maybe should be optional / opt in
 //y2 - how to run a transaction as a user
 //p1 - enum column

package/esm/SseSubscriptionServer.d.ts

@@ -1,25 +0,0 @@
-/// <reference types="node" />
-import type { GenericResponse } from './server/index';
-import type { Remult } from './src/context';
-import type { SubscriptionServer } from './src/live-query/SubscriptionServer';
-export declare class SseSubscriptionServer implements SubscriptionServer {
-    private canUserConnectToChannel?;
-    constructor(canUserConnectToChannel?: (channel: string, remult: Remult) => boolean);
-    publishMessage<T>(channel: string, message: any): Promise<void>;
-}
-export interface ResponseRequiredForSSE {
-    write(data: string): void;
-    writeHead(status: number, headers: any): void;
-    flush?(): void;
-}
-export declare class clientConnection {
-    response: GenericResponse & ResponseRequiredForSSE;
-    channels: Record<string, boolean>;
-    timeOutRef: NodeJS.Timeout;
-    close(): void;
-    closed: boolean;
-    write(eventData: string, eventType?: string): void;
-    connectionId: any;
-    constructor(response: GenericResponse & ResponseRequiredForSSE);
-    sendLiveMessage(): void;
-}

package/esm/ably.d.ts

@@ -1,13 +0,0 @@
-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';
-export declare class AblySubscriptionClient implements SubscriptionClient {
-    private ably;
-    constructor(ably: Ably.Types.RealtimePromise);
-    openConnection(onReconnect: VoidFunction): Promise<SubscriptionClientConnection>;
-}
-export declare class AblySubscriptionServer implements SubscriptionServer {
-    private ably;
-    constructor(ably: Ably.Types.RestPromise);
-    publishMessage<T>(channel: string, message: T): Promise<void>;
-}

package/esm/assign.d.ts

@@ -1 +0,0 @@
-export declare function assign<T>(item: T, valuesToSet: Partial<T>): T;

package/esm/classType.d.ts

@@ -1,3 +0,0 @@
-export type ClassType<T> = {
-    new (...args: any[]): T;
-};

package/esm/graphql.d.ts

@@ -1,14 +0,0 @@
-import type { ClassType } from './classType';
-import { Remult } from './index';
-export declare function remultGraphql(options: {
-    removeComments?: boolean;
-    entities: ClassType<any>[];
-    getRemultFromRequest?: (req: any) => Remult;
-}): {
-    resolvers: {
-        Query: Record<string, unknown>;
-        Mutation: Record<string, unknown>;
-    };
-    rootValue: Record<string, any>;
-    typeDefs: string;
-};

package/esm/index.d.ts

@@ -1,46 +0,0 @@
-import type { ClassType } from './classType';
-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';
-export { Field, Fields, StringFieldOptions, Relations, } from './src/remult3/Fields';
-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, 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';
-export { InMemoryDataProvider } from './src/data-providers/in-memory-database';
-export { WebSqlDataProvider } from './src/data-providers/web-sql-data-provider';
-export { SqlDatabase } from './src/data-providers/sql-database';
-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, 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/inputTypes.d.ts

@@ -1,9 +0,0 @@
-export declare class InputTypes {
-    static number: string;
-    static date: string;
-    static checkbox: string;
-    static password: string;
-    static email: string;
-    static tel: string;
-    static time: string;
-}

package/esm/internals.d.ts

@@ -1,7 +0,0 @@
-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 { RelationInfo } from './src/remult3/remult3';
-export { ClassType } from './classType';

package/esm/live-query/data-provider-live-query-storage.d.ts

@@ -1,23 +0,0 @@
-import type { DataProvider, Storage } from '../src/data-interfaces';
-import type { LiveQueryStorage, StoredQuery } from '../src/live-query/SubscriptionServer';
-import type { Repository } from '../src/remult3/remult3';
-import { EntityBase } from '../src/remult3/RepositoryImplementation';
-export declare class DataProviderLiveQueryStorage implements LiveQueryStorage, Storage {
-    repo: Promise<Repository<LiveQueryStorageEntity>>;
-    dataProvider: Promise<DataProvider>;
-    constructor(dataProvider: DataProvider | Promise<DataProvider> | (() => Promise<DataProvider | undefined>));
-    ensureSchema(): Promise<void>;
-    add({ id, entityKey, data }: StoredQuery): Promise<void>;
-    remove(queryId: string): Promise<void>;
-    forEach(entityKey: string, callback: (args: {
-        query: StoredQuery;
-        setData(data: any): Promise<void>;
-    }) => Promise<void>): Promise<void>;
-    keepAliveAndReturnUnknownQueryIds(queryIds: string[]): Promise<string[]>;
-}
-export declare class LiveQueryStorageEntity extends EntityBase {
-    id: string;
-    entityKey: string;
-    data: any;
-    lastUsedIso: string;
-}

package/esm/myLog.d.ts

@@ -1 +0,0 @@
-export declare function writeToLog(what: any): Promise<void>;

package/esm/postgres/index.d.ts

@@ -1,2 +0,0 @@
-export * from './postgres-data-provider';
-export * from './schema-builder';

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

@@ -1,36 +0,0 @@
-import type { ClientBase, PoolConfig, QueryResult } from 'pg';
-import { Remult } from '../src/context';
-import { SqlDatabase } from '../src/data-providers/sql-database';
-import type { EntityMetadata } from '../src/remult3/remult3';
-import type { SqlCommand, SqlImplementation } from '../src/sql-command';
-export interface PostgresPool extends PostgresCommandSource {
-    connect(): Promise<PostgresClient>;
-}
-export interface PostgresClient extends PostgresCommandSource {
-    release(): void;
-}
-export declare class PostgresDataProvider implements SqlImplementation {
-    private pool;
-    supportsJsonColumnType: boolean;
-    static getDb(remult?: Remult): ClientBase;
-    entityIsUsedForTheFirstTime(entity: EntityMetadata): Promise<void>;
-    getLimitSqlSyntax(limit: number, offset: number): string;
-    createCommand(): SqlCommand;
-    constructor(pool: PostgresPool);
-    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 createPostgresDataProvider(options?: {
-    connectionString?: string;
-    sslInDev?: boolean;
-    configuration?: 'heroku' | PoolConfig;
-}): Promise<SqlDatabase>;
-export declare function preparePostgresQueueStorage(sql: SqlDatabase): Promise<import("../server/expressBridge").EntityQueueStorage>;

package/esm/postgres/schema-builder.d.ts

@@ -1,20 +0,0 @@
-import type { FieldMetadata } from '../src/column-interfaces';
-import type { Remult } from '../src/context';
-import type { SqlDatabase } from '../src/data-providers/sql-database';
-import type { EntityMetadata } from '../src/remult3/remult3';
-export declare function postgresColumnSyntax(x: FieldMetadata, dbName: string): string;
-export declare function verifyStructureOfAllEntities(db: SqlDatabase, remult: Remult): Promise<void>;
-export declare class PostgresSchemaBuilder {
-    private pool;
-    private removeQuotes;
-    private whereTableAndSchema;
-    private schemaAndName;
-    private schemaOnly;
-    verifyStructureOfAllEntities(remult?: Remult): Promise<void>;
-    ensureSchema(entities: EntityMetadata<any>[]): Promise<void>;
-    createIfNotExist(entity: EntityMetadata): Promise<void>;
-    addColumnIfNotExist<T extends EntityMetadata>(entity: T, c: (e: T) => FieldMetadata): Promise<void>;
-    verifyAllColumns<T extends EntityMetadata>(entity: T): Promise<void>;
-    specifiedSchema: string;
-    constructor(pool: SqlDatabase, schema?: string);
-}

package/esm/remult-express.d.ts

@@ -1,9 +0,0 @@
-import * as express from 'express';
-import type { RemultServerCore, RemultServerOptions } from './server/expressBridge';
-export declare function remultExpress(options?: RemultServerOptions<express.Request> & {
-    bodyParser?: boolean;
-    bodySizeLimit?: string;
-}): RemultExpressServer;
-export type RemultExpressServer = express.RequestHandler & RemultServerCore<express.Request> & {
-    withRemult: (req: express.Request, res: express.Response, next: VoidFunction) => void;
-};

package/esm/remult-fastify.d.ts

@@ -1,6 +0,0 @@
-import type { FastifyPluginCallback, FastifyRequest } from 'fastify';
-import type { RemultServerCore, RemultServerOptions } from './server/expressBridge';
-export declare function remultFastify(options: RemultServerOptions<FastifyRequest>): RemultFastifyServer;
-export type RemultFastifyServer = FastifyPluginCallback & RemultServerCore<FastifyRequest> & {
-    withRemult<T>(req: FastifyRequest, what: () => Promise<T>): Promise<T>;
-};

package/esm/remult-fresh.d.ts

@@ -1,17 +0,0 @@
-import type { RemultServerCore, RemultServerOptions } from './server/expressBridge';
-export declare function remultFresh(options: RemultServerOptions<FreshRequest>, response: FreshResponse): RemultFresh;
-export interface RemultFresh extends RemultServerCore<FreshRequest> {
-    handle(req: FreshRequest, ctx: FreshContext): Promise<any>;
-}
-export interface FreshRequest {
-    url: string;
-    method: string;
-    json: () => Promise<any>;
-}
-export interface FreshContext {
-    next: () => Promise<any>;
-}
-export interface FreshResponse {
-    new (body?: any | undefined, init?: ResponseInit): any;
-    json(data: unknown, init?: ResponseInit): any;
-}

package/esm/remult-hapi.d.ts

@@ -1,6 +0,0 @@
-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-knex/index.d.ts

@@ -1,30 +0,0 @@
-import type { Knex } from 'knex';
-import type { Remult } from '../src/context';
-import type { FieldMetadata } from '../src/column-interfaces';
-import type { DataProvider, EntityDataProvider } from '../src/data-interfaces';
-import type { EntityFilter, EntityMetadata } from '../src/remult3/remult3';
-import type { RepositoryOverloads } from '../src/remult3/RepositoryImplementation';
-export declare class KnexDataProvider implements DataProvider {
-    knex: Knex;
-    constructor(knex: Knex);
-    static getDb(remult?: Remult): Knex<any, any[]>;
-    getEntityDataProvider(entity: EntityMetadata<any>): EntityDataProvider;
-    transaction(action: (dataProvider: DataProvider) => Promise<void>): Promise<void>;
-    static rawFilter(build: CustomKnexFilterBuilderFunction): EntityFilter<any>;
-    static filterToRaw<entityType>(entity: RepositoryOverloads<entityType>, condition: EntityFilter<entityType>): Promise<(knex: any) => void>;
-    isProxy?: boolean;
-    ensureSchema(entities: EntityMetadata<any>[]): Promise<void>;
-}
-export type CustomKnexFilterBuilderFunction = () => Promise<(builder: Knex.QueryBuilder) => void>;
-export declare class KnexSchemaBuilder {
-    private knex;
-    verifyStructureOfAllEntities(remult?: Remult): Promise<void>;
-    ensureSchema(entities: EntityMetadata<any>[]): Promise<void>;
-    createIfNotExist(entity: EntityMetadata): Promise<void>;
-    addColumnIfNotExist<T extends EntityMetadata>(entity: T, c: (e: T) => FieldMetadata): Promise<void>;
-    verifyAllColumns<T extends EntityMetadata>(entity: T): Promise<void>;
-    additionalWhere: string;
-    constructor(knex: Knex);
-}
-export declare function buildColumn(x: FieldMetadata, dbName: string, b: Knex.CreateTableBuilder, supportsJson?: boolean): void;
-export declare function createKnexDataProvider(config: Knex.Config): Promise<KnexDataProvider>;

package/esm/remult-mongo.d.ts

@@ -1,24 +0,0 @@
-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 {
-    private db;
-    private client;
-    constructor(db: Db, client: MongoClient | undefined, options?: {
-        session?: ClientSession;
-        disableTransactions?: boolean;
-    });
-    session?: ClientSession;
-    disableTransactions: boolean;
-    static getDb(remult?: Remult): {
-        db: Db;
-        session: ClientSession;
-    };
-    getEntityDataProvider(entity: EntityMetadata<any>): EntityDataProvider;
-    transaction(action: (dataProvider: DataProvider) => Promise<void>): Promise<void>;
-    static filterToRaw<entityType>(entity: RepositoryOverloads<entityType>, condition: EntityFilter<entityType>): Promise<{
-        $and: any[];
-    } | {
-        $and?: undefined;
-    }>;
-}