remult 0.22.6 → 0.22.7-exp.0

package/SseSubscriptionServer.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
-import { GenericResponse } from './server/index';
-import { Remult } from './src/context';
-import { SubscriptionServer } from './src/live-query/SubscriptionServer';
+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);

package/ably.d.ts

@@ -1,6 +1,6 @@
 import type * as Ably from '../../node_modules/ably';
-import type { SubscriptionServer } from './src/live-query/SubscriptionServer';
 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);

package/esm/SseSubscriptionServer.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
-import { GenericResponse } from './server/index';
-import { Remult } from './src/context';
-import { SubscriptionServer } from './src/live-query/SubscriptionServer';
+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);

package/esm/ably.d.ts

@@ -1,6 +1,6 @@
 import type * as Ably from '../../node_modules/ably';
-import type { SubscriptionServer } from './src/live-query/SubscriptionServer';
 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);

package/esm/graphql.d.ts

@@ -1,5 +1,5 @@
-import { Remult } from './index';
 import type { ClassType } from './classType';
+import { Remult } from './index';
 export declare function remultGraphql(options: {
     removeComments?: boolean;
     entities: ClassType<any>[];

package/esm/graphql.js

@@ -1,5 +1,5 @@
-import { DataApi } from './src/data-api';
 import { Remult, remult } from './index';
+import { DataApi } from './src/data-api';
 const v2ConnectionAndPagination = false;
 const andImplementation = false;
 let _removeComments = false;
@@ -208,16 +208,16 @@ export function remultGraphql(options) {
                 {
                     key: 'limit',
                     value: 'Int',
-                    comment: `
-For **page by page** pagination.
-Limit the number of result. 
+                    comment: `
+For **page by page** pagination.
+Limit the number of result. 
 _Side note: \`Math.ceil(totalCount / limit)\` to determine how many pages there are._`,
                 },
                 {
                     key: 'page',
                     value: 'Int',
-                    comment: `
-For **page by page** pagination.
+                    comment: `
+For **page by page** pagination.
 Select a dedicated page.`,
                 },
                 {
@@ -235,26 +235,26 @@ Select a dedicated page.`,
                 queryArgsConnection.push({
                     key: 'first',
                     value: 'Int',
-                    comment: `
-        For **forward cursor** pagination
+                    comment: `
+        For **forward cursor** pagination
         Takes the \`first\`: \`n\` elements from the list.`,
                 }, {
                     key: 'after',
                     value: 'String',
-                    comment: `
-        For **forward cursor** pagination
+                    comment: `
+        For **forward cursor** pagination
         \`after\` this \`cursor\`.`,
                 }, {
                     key: 'last',
                     value: 'Int',
-                    comment: `
-        For **backward cursor** pagination
+                    comment: `
+        For **backward cursor** pagination
         Takes the \`last\`: \`n\` elements from the list.`,
                 }, {
                     key: 'before',
                     value: 'String',
-                    comment: `
-        For **backward cursor** pagination
+                    comment: `
+        For **backward cursor** pagination
         \`before\` this \`cursor\`.`,
                 });
             }
@@ -491,10 +491,11 @@ Select a dedicated page.`,
                             return null;
                         };
                     });
-                    // will do: Category.tasks
+                    // will do: Category.tasks (actually: Category.tasksOfcategory & tasksOfcategory2)
                     const refT = upsertTypes(getMetaType(ref), 'type_impl_node');
+                    const keyOf = key + 'Of' + f.key;
                     refT.fields.push({
-                        key,
+                        key: keyOf,
                         args: queryArgsConnection,
                         value: connectionKey,
                         order: 10,
@@ -502,7 +503,7 @@ Select a dedicated page.`,
                     });
                     refT.query.resultProcessors.push((r) => {
                         const val = r.id;
-                        r[key] = async (args, req, gqlInfo) => {
+                        r[keyOf] = async (args, req, gqlInfo) => {
                             return await root[key]({
                                 where: { ...args.where, [f.key]: { eq: val } },
                                 options: { ...args.limit, ...args.page, ...args.orderBy },
@@ -668,7 +669,7 @@ Select a dedicated page.`,
                 : ``;
             return `${type}${orderByStr}${whereTypeStr}${whereTypeSubFieldsStr}`;
         })
-            .join(`\n\n`)}
+            .join(`\n\n`)}
 `,
     };
 }
@@ -690,12 +691,12 @@ function blockFormat(obj) {
     if (obj.data.length === 0) {
         return ``;
     }
-    const str = `${obj.prefix} {
-  ${obj.data.join('\n  ')}
+    const str = `${obj.prefix} {
+  ${obj.data.join('\n  ')}
 }`;
-    let commentsStr = `"""
-${obj.comment}
-"""
+    let commentsStr = `"""
+${obj.comment}
+"""
 `;
     if (_removeComments) {
         commentsStr = ``;
@@ -706,16 +707,16 @@ function argsFormat(args) {
     if (args) {
         return `(${args
             .map((arg) => {
-            let strComment = `
-    """
-    ${arg.comment}
-    """
+            let strComment = `
+    """
+    ${arg.comment}
+    """
 `;
             if (_removeComments || !arg.comment) {
                 strComment = ``;
             }
             if (strComment) {
-                return `${strComment}    ${arg.key}: ${arg.value}
+                return `${strComment}    ${arg.key}: ${arg.value}
   `;
             }
             return `${arg.key}: ${arg.value}`;
@@ -726,9 +727,9 @@ function argsFormat(args) {
 }
 function fieldFormat(field) {
     // First, the comment
-    let strComment = `"""
-  ${field.comment}
-  """
+    let strComment = `"""
+  ${field.comment}
+  """
 `;
     if (_removeComments || !field.comment) {
         strComment = ``;

package/esm/index.d.ts

@@ -1,4 +1,7 @@
-export { Field, Fields, FieldsMetadata, Entity, IdEntity, EntityBase, ControllerBase, FieldRef, IdFieldRef, FieldsRef, EntityMetadata, EntityOrderBy, EntityFilter, FindOptions, QueryResult, QueryOptions, Repository, FieldType, FindFirstOptions, ComparisonValueFilter, ValueFilter, IdFilter, ContainsStringValueFilter, getFields, EntityRef, getEntityRef, SortSegments, ValueListFieldType, getValueList, ValueListFieldOptions, ValueListInfo, OmitEB, Paginator, CaptionTransformer, LiveQuery, LiveQueryChangeInfo, } from './src/remult3';
+export { OmitEB, FieldsMetadata, FieldRef, IdFieldRef, FieldsRef, EntityMetadata, EntityOrderBy, EntityFilter, FindOptions, QueryResult, QueryOptions, Repository, FindFirstOptions, ComparisonValueFilter, ValueFilter, IdFilter, ContainsStringValueFilter, EntityRef, SortSegments, Paginator, LiveQuery, LiveQueryChangeInfo, } from './src/remult3/remult3';
+export { Field, Fields, IdEntity, 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 { StringFieldOptions } from './src/remult3/RepositoryImplementation';
 export { describeClass } from './src/remult3/DecoratorReplacer';
 export { EntityOptions } from './src/entity';
@@ -17,7 +20,8 @@ export { Controller, BackendMethodOptions, BackendMethod, ProgressListener, } fr
 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 { OneToMany, CompoundIdField } from './src/column';
+export { OneToMany } from './src/column';
+export { CompoundIdField } from './src/CompoundIdField';
 export { Filter } from './src/filter/filter-interfaces';
 export { UrlBuilder } from './urlBuilder';
 export { Validators } from './src/validators';

package/esm/index.js

@@ -1,7 +1,6 @@
-/*
- * Public API Surface of remult
- */
-export { Field, Fields, Entity, IdEntity, EntityBase, ControllerBase, FieldType, getFields, getEntityRef, ValueListFieldType, getValueList, ValueListInfo, CaptionTransformer, } from './src/remult3';
+export { Field, Fields, IdEntity, 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 { 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
@@ -14,7 +13,8 @@ export { JsonDataProvider, } from './src/data-providers/json-data-provider'; //V
 export { Controller, BackendMethod, ProgressListener, } from './src/server-action';
 export { Allow, Remult, isBackend, EventSource, } from './src/context';
 export { Sort } from './src/sort';
-export { OneToMany, CompoundIdField } from './src/column';
+export { OneToMany } from './src/column';
+export { CompoundIdField } from './src/CompoundIdField';
 export { Filter } from './src/filter/filter-interfaces';
 export { UrlBuilder } from './urlBuilder';
 export { Validators } from './src/validators';

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

@@ -1,6 +1,7 @@
-import { Storage, DataProvider } from '../src/data-interfaces';
-import { LiveQueryStorage, StoredQuery } from '../src/live-query/SubscriptionServer';
-import { EntityBase, Repository } from '../src/remult3';
+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>;

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

@@ -1,7 +1,8 @@
 import { __decorate, __metadata } from "tslib";
 import { initDataProvider } from '../server/initDataProvider';
 import { allEntities, Remult } from '../src/context';
-import { Entity, EntityBase, Fields } from '../src/remult3';
+import { EntityBase, Fields } from '../src/remult3/RepositoryImplementation';
+import { Entity } from '../src/remult3/entity';
 export class DataProviderLiveQueryStorage {
     constructor(dataProvider) {
         this.dataProvider = initDataProvider(dataProvider);

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

@@ -1,8 +1,8 @@
-import { ClientBase, PoolConfig, QueryResult } from 'pg';
+import type { ClientBase, PoolConfig, QueryResult } from 'pg';
 import { Remult } from '../src/context';
-import { EntityMetadata } from '../src/remult3';
-import { SqlCommand, SqlImplementation } from '../src/sql-command';
 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>;
 }

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

@@ -1,7 +1,7 @@
 import { Pool } from 'pg';
 import { Remult } from '../src/context';
-import { PostgresSchemaBuilder, } from './schema-builder';
 import { SqlDatabase } from '../src/data-providers/sql-database';
+import { PostgresSchemaBuilder } from './schema-builder';
 export class PostgresDataProvider {
     constructor(pool) {
         this.pool = pool;

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

@@ -1,16 +1,19 @@
-import { FieldMetadata } from '../src/column-interfaces';
-import { Remult } from '../src/context';
-import { SqlDatabase } from '../src/data-providers/sql-database';
-import { EntityMetadata } from '../src/remult3';
+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;
     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;
+    specifiedSchema: string;
     constructor(pool: SqlDatabase, schema?: string);
 }

package/esm/postgres/schema-builder.js

@@ -1,7 +1,7 @@
 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';
+import { isAutoIncrement } from '../src/remult3/RepositoryImplementation';
 import { ValueConverters } from '../src/valueConverters';
 export function postgresColumnSyntax(x, dbName) {
     let result = dbName;
@@ -41,11 +41,48 @@ export async function verifyStructureOfAllEntities(db, remult) {
 export class PostgresSchemaBuilder {
     constructor(pool, schema) {
         this.pool = pool;
-        this.additionalWhere = '';
+        this.specifiedSchema = '';
         if (schema) {
-            this.additionalWhere = " and table_schema='" + schema + "'";
+            this.specifiedSchema = schema;
         }
     }
+    removeQuotes(s) {
+        if (s.startsWith('"') && s.endsWith('"')) {
+            return s.substring(1, s.length - 1);
+        }
+        return s.toLocaleLowerCase();
+    }
+    whereTableAndSchema(cmd, e) {
+        let table = '';
+        let schema = '';
+        if (this.specifiedSchema) {
+            schema = this.specifiedSchema;
+        }
+        const splited = e.$entityName.split('.');
+        // let's prioritize the specified schema at dbName level
+        if (splited.length > 1) {
+            schema = splited[0];
+            table = splited[1];
+        }
+        else {
+            table = splited[0];
+        }
+        const where = [];
+        if (schema) {
+            where.push(`table_schema=${cmd.addParameterAndReturnSqlToken(this.removeQuotes(schema))}`);
+        }
+        where.push(`table_name=${cmd.addParameterAndReturnSqlToken(this.removeQuotes(table))}`);
+        return where.join(' AND ');
+    }
+    schemaAndName(e) {
+        if (e.$entityName.includes('.')) {
+            return e.$entityName;
+        }
+        if (this.specifiedSchema) {
+            return `${this.specifiedSchema}.${e.$entityName}`;
+        }
+        return e.$entityName;
+    }
     async verifyStructureOfAllEntities(remult) {
         if (!remult) {
             remult = defaultRemult;
@@ -82,9 +119,8 @@ export class PostgresSchemaBuilder {
         var c = this.pool.createCommand();
         let e = await dbNamesOf(entity);
         await c
-            .execute('select 1 from information_Schema.tables where table_name=' +
-            c.addParameterAndReturnSqlToken(e.$entityName.toLowerCase()) +
-            this.additionalWhere)
+            .execute(`SELECT 1 FROM information_Schema.tables WHERE ` +
+            `${this.whereTableAndSchema(c, e)}`)
             .then(async (r) => {
             if (r.rows.length == 0) {
                 let result = '';
@@ -102,7 +138,7 @@ export class PostgresSchemaBuilder {
                             result += ' primary key';
                     }
                 }
-                let sql = 'create table ' + e.$entityName + ' (' + result + '\r\n)';
+                let sql = `CREATE table ${this.schemaAndName(e)} (${result}\r\n)`;
                 if (PostgresSchemaBuilder.logToConsole)
                     console.info(sql);
                 await this.pool.execute(sql);
@@ -116,10 +152,11 @@ export class PostgresSchemaBuilder {
         try {
             let cmd = this.pool.createCommand();
             const colName = e.$dbNameOf(c(entity));
-            if ((await cmd.execute(`select 1   
-        FROM information_schema.columns 
-        WHERE table_name=${cmd.addParameterAndReturnSqlToken(e.$entityName.toLocaleLowerCase())} and column_name=${cmd.addParameterAndReturnSqlToken(colName.toLocaleLowerCase())}` + this.additionalWhere)).rows.length == 0) {
-                let sql = `alter table ${e.$entityName} add column ${postgresColumnSyntax(c(entity), colName)}`;
+            if ((await cmd.execute(`SELECT 1 FROM information_schema.columns WHERE ` +
+                `${this.whereTableAndSchema(cmd, e)} ` +
+                `AND column_name=${cmd.addParameterAndReturnSqlToken(colName.toLocaleLowerCase())}`)).rows.length == 0) {
+                let sql = `ALTER table ${this.schemaAndName(e)} ` +
+                    `ADD column ${postgresColumnSyntax(c(entity), colName)}`;
                 if (PostgresSchemaBuilder.logToConsole)
                     console.info(sql);
                 await this.pool.execute(sql);
@@ -133,16 +170,16 @@ export class PostgresSchemaBuilder {
         try {
             let cmd = this.pool.createCommand();
             let e = await dbNamesOf(entity);
-            let cols = (await cmd.execute(`select column_name   
-        FROM information_schema.columns 
-        WHERE table_name=${cmd.addParameterAndReturnSqlToken(e.$entityName.toLocaleLowerCase())} ` + this.additionalWhere)).rows.map((x) => x.column_name.toLocaleLowerCase());
+            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) {
                 if (!isDbReadonly(col, e)) {
                     let colName = e.$dbNameOf(col).toLocaleLowerCase();
                     if (colName.startsWith('"') && colName.endsWith('"'))
                         colName = colName.substring(1, colName.length - 1);
                     if (!cols.includes(colName)) {
-                        let sql = `alter table ${e.$entityName} add column ${postgresColumnSyntax(col, e.$dbNameOf(col))}`;
+                        let sql = `ALTER table ${this.schemaAndName(e)} ` +
+                            `add column ${postgresColumnSyntax(col, e.$dbNameOf(col))}`;
                         if (PostgresSchemaBuilder.logToConsole)
                             console.info(sql);
                         await this.pool.execute(sql);

package/esm/remult-fastify.d.ts

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

package/esm/remult-fresh.d.ts

@@ -1,4 +1,4 @@
-import { RemultServerOptions, RemultServerCore } from './server/expressBridge';
+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>;

package/esm/remult-fresh.js

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

package/esm/remult-knex/index.d.ts

@@ -1,8 +1,9 @@
 import type { Knex } from 'knex';
-import { Remult } from '../src/context';
-import { EntityFilter, EntityMetadata, RepositoryOverloads } from '../src/remult3';
-import { DataProvider, EntityDataProvider } from '../src/data-interfaces';
-import { FieldMetadata } from '../src/column-interfaces';
+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);

package/esm/remult-knex/index.js

@@ -1,11 +1,12 @@
-import { customDatabaseFilterToken, Filter, } from '../src/filter/filter-interfaces';
-import { dbNamesOf, isDbReadonly, } from '../src/filter/filter-consumer-bridge-to-sql-request';
 import { allEntities } from '../src/context';
-import { isAutoIncrement, getRepository, } from '../src/remult3';
-import { ValueConverters } from '../src/valueConverters';
-import { CompoundIdField } from '../src/column';
-import { Sort } from '../src/sort';
+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';
 export class KnexDataProvider {
     constructor(knex) {
         this.knex = knex;
@@ -174,7 +175,7 @@ class KnexEntityDataProvider {
         const e = await this.init();
         let resultFilter;
         if (this.entity.idMetadata.field instanceof CompoundIdField)
-            resultFilter = this.entity.idMetadata.field.resultIdFilter(undefined, data);
+            resultFilter = resultCompoundIdFilter(this.entity.idMetadata.field, undefined, data);
         else
             resultFilter = Filter.fromEntityFilter(this.entity, this.entity.idMetadata.getIdFilter(data[this.entity.idMetadata.field.key]));
         let insertObject = {};
@@ -192,7 +193,8 @@ class KnexEntityDataProvider {
         let insert = this.knex(e.$entityName).insert(insertObject);
         if (isAutoIncrement(this.entity.idMetadata.field)) {
             let newId;
-            if (this.knex.client.config.client === 'mysql2' || this.knex.client.config.client === 'mysql') {
+            if (this.knex.client.config.client === 'mysql2' ||
+                this.knex.client.config.client === 'mysql') {
                 let result = await insert;
                 newId = result[0];
             }
@@ -380,7 +382,9 @@ export class KnexSchemaBuilder {
 KnexSchemaBuilder.logToConsole = true;
 function supportsJson(knex) {
     const client = knex.client.config.client;
-    if (client?.includes('sqlite3') || client?.includes('mssql') || client?.includes('mysql'))
+    if (client?.includes('sqlite3') ||
+        client?.includes('mssql') ||
+        client?.includes('mysql'))
         return false;
     return true;
 }

package/esm/remult-mongo.d.ts

@@ -1,6 +1,6 @@
-import type { MongoClient, Db, ClientSession } from 'mongodb';
-import { DataProvider, EntityDataProvider, EntityFilter, EntityMetadata, Remult } from '.';
-import { RepositoryOverloads } from './src/remult3';
+import type { ClientSession, Db, 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;

package/esm/remult-mongo.js

@@ -1,7 +1,8 @@
-import { CompoundIdField, Filter, } from '.';
-import { dbNamesOf, } from './src/filter/filter-consumer-bridge-to-sql-request';
-import { getRepository, } from './src/remult3';
+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';
 export class MongoDataProvider {
     constructor(db, client, options) {
         this.db = db;
@@ -121,7 +122,7 @@ class MongoEntityDataProvider {
             resultFilter = this.entity.idMetadata.getIdFilter(data.id);
         for (const x of this.entity.fields) {
             if (x instanceof CompoundIdField) {
-                resultFilter = x.resultIdFilter(id, data);
+                resultFilter = resultCompoundIdFilter(x, id, data);
             }
         }
         let newR = {};

package/esm/remult-next.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
-import type { GetServerSideProps, NextApiRequest, PreviewData, NextApiHandler } from 'next';
+import type { GetServerSideProps, NextApiHandler, NextApiRequest, PreviewData } from 'next';
 import type { ParsedUrlQuery } from 'querystring';
-import { RemultServerCore, RemultServerOptions } from './server';
+import type { RemultServerCore, RemultServerOptions } from './server';
 export declare function remultNext(options?: RemultServerOptions<NextApiRequest>): RemultNextServer;
 export declare type RemultNextServer = RemultServerCore<NextApiRequest> & NextApiHandler & {
     getServerSideProps<P extends {

package/esm/remult-next.js

@@ -1,4 +1,4 @@
-import { createRemultServer, } from './server';
+import { createRemultServer } from './server';
 export function remultNext(options) {
     let result = createRemultServer(options, {
         buildGenericRequestInfo: (req) => req,

package/esm/remult-sveltekit.d.ts

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

package/esm/remult-sveltekit.js

@@ -1,4 +1,4 @@
-import { createRemultServer, } from './server';
+import { createRemultServer } from './server';
 export function remultSveltekit(options) {
     let result = createRemultServer(options, {
         buildGenericRequestInfo: (event) => ({

package/esm/server/JsonEntityFileStorage.d.ts

@@ -1,4 +1,5 @@
-import { JsonDataProvider, JsonEntityStorage } from '../index';
+import type { JsonEntityStorage } from '../index';
+import { JsonDataProvider } from '../index';
 export declare class JsonEntityFileStorage implements JsonEntityStorage {
     private folderPath;
     getItem(entityDbName: string): string;

package/esm/server/JsonEntityFileStorage.js

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

package/esm/server/expressBridge.d.ts

@@ -1,9 +1,11 @@
-import { queuedJobInfoResponse } from '../src/server-action';
-import type { DataProvider } from '../src/data-interfaces';
-import { Remult, UserInfo } from '../src/context';
 import type { ClassType } from '../classType';
-import { IdEntity, Repository } from '../src/remult3';
-import { LiveQueryStorage, SubscriptionServer } from '../src/live-query/SubscriptionServer';
+import type { UserInfo } from '../src/context';
+import { Remult } from '../src/context';
+import type { DataProvider } from '../src/data-interfaces';
+import type { LiveQueryStorage, SubscriptionServer } from '../src/live-query/SubscriptionServer';
+import { IdEntity } from '../src/remult3/RepositoryImplementation';
+import type { Repository } from '../src/remult3/remult3';
+import type { queuedJobInfoResponse } from '../src/server-action';
 export interface RemultServerOptions<RequestType> {
     /**Entities to use for the api */
     entities?: ClassType<any>[];