remult 0.25.8-exp.8 → 0.25.8

package/README.md

@@ -5,17 +5,23 @@
   <h1>Remult</h1>
   <p>Full-stack CRUD, simplified, with SSOT TypeScript entities</p>
 	<a href="https://circleci.com/gh/remult/remult/tree/master" rel="nofollow">
-		<img alt="CircleCI" src="https://circleci.com/gh/remult/remult/tree/master.svg?style=shield"></a>
+		<img alt="CircleCI" src="https://circleci.com/gh/remult/remult/tree/master.svg?style=shield">
+	</a>
 	<a href="https://codecov.io/gh/remult/remult" rel="nofollow">
-        	<img src="https://codecov.io/gh/remult/remult/branch/master/graph/badge.svg?token=LYWQRUN3D1"/></a>
+        	<img src="https://codecov.io/gh/remult/remult/branch/master/graph/badge.svg?token=LYWQRUN3D1"/>
+      	</a>
     	<a href="https://raw.githubusercontent.com/remult/remult/master/LICENSE" rel="nofollow">
-		<img alt="GitHub license" src="https://img.shields.io/badge/license-MIT-blue.svg"></a>
+		<img alt="GitHub license" src="https://img.shields.io/badge/license-MIT-blue.svg">
+	</a>
 	<a href="https://www.npmjs.com/package/remult" rel="nofollow">
-		<img alt="npm version" src="https://badge.fury.io/js/remult.svg"></a>
+		<img alt="npm version" src="https://badge.fury.io/js/remult.svg">
+	</a>
 	<a href="https://www.npmjs.com/package/remult" rel="nofollow">
-		<img alt="npm downloads" src="https://img.shields.io/npm/dm/remult"></a>
+		<img alt="npm downloads" src="https://img.shields.io/npm/dm/remult">
+	</a>
 	<a href="https://discord.gg/GXHk7ZfuG5" rel="nofollow">
-		<img alt="Join Discord" src="https://badgen.net/discord/members/GXHk7ZfuG5?icon=discord&label=Discord"/></a>
+		<img alt="Join Discord" src="https://badgen.net/discord/online-members/GXHk7ZfuG5?icon=discord&label=Discord"/>
+	</a>
 </div>
 
 <br/>

package/esm/graphql.js

@@ -904,7 +904,7 @@ export function translateWhereToRestBody(fields, { where }) {
         }
     }
     if (where.OR) {
-        result.OR = where.OR.map((where) => translateWhereToRestBody(fields, { where }).where);
+        result.OR = where.OR.map((where) => translateWhereToRestBody(fields, { where }));
     }
-    return { where: result };
+    return result;
 }

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

@@ -1,4 +1,3 @@
-import { remult as defaultRemult } from '../src/remult-proxy.js';
 import pg from 'pg';
 const { Pool } = pg;
 import { Remult } from '../src/context.js';
@@ -8,11 +7,9 @@ export class PostgresDataProvider {
     pool;
     options;
     supportsJsonColumnType = true;
-    static getDb(dataProvider) {
-        const r = (dataProvider || defaultRemult.dataProvider);
-        if (!r._getSourceSql)
-            throw 'the data provider is not an SqlDatabase';
-        const me = r._getSourceSql();
+    static getDb(remult) {
+        const sql = SqlDatabase.getDb(remult);
+        const me = sql._getSourceSql();
         if (!me.pool) {
             throw 'the data provider is not a PostgresDataProvider';
         }
@@ -38,21 +35,6 @@ export class PostgresDataProvider {
             this.pool = new PostgresSchemaWrapper(pool, options.schema);
         }
     }
-    end() {
-        return this.pool.end();
-    }
-    provideMigrationBuilder(builder) {
-        var db = new SqlDatabase(this);
-        var sb = new PostgresSchemaBuilder(db, this.options?.schema);
-        return {
-            addColumn: async (meta, field) => {
-                builder.addSql(await sb.getAddColumnScript(meta, field));
-            },
-            createTable: async (meta) => {
-                builder.addSql(await sb.createTableScript(meta));
-            },
-        };
-    }
     wrapIdentifier = (name) => name
         .split('.')
         .map((name) => name.startsWith('"') ? name : '"' + name.replace(/"/g, '""') + '"')
@@ -190,7 +172,4 @@ export class PostgresSchemaWrapper {
             c.release();
         }
     }
-    end() {
-        return this.pool.end();
-    }
 }

package/esm/postgres/schema-builder.js

@@ -1,4 +1,4 @@
-import { dbNamesOf, shouldCreateEntity, shouldNotCreateField, } from '../src/filter/filter-consumer-bridge-to-sql-request.js';
+import { dbNamesOf, shouldNotCreateField, } from '../src/filter/filter-consumer-bridge-to-sql-request.js';
 import { remult as defaultRemult } from '../src/remult-proxy.js';
 import { remultStatic } from '../src/remult-static.js';
 import { isAutoIncrement } from '../src/remult3/RepositoryImplementation.js';
@@ -19,7 +19,7 @@ export function postgresColumnSyntax(x, dbName) {
             if (x.valueConverter == ValueConverters.DateOnly)
                 result += ' date';
             else
-                result += ' timestamptz';
+                result += ' timestamp';
         else
             result += ' ' + x.valueConverter.fieldTypeInDb;
     }
@@ -109,9 +109,11 @@ export class PostgresSchemaBuilder {
         for (const entity of entities) {
             let e = await dbNamesOf(entity, this.pool.wrapIdentifier);
             try {
-                if (shouldCreateEntity(entity, e)) {
-                    await this.createIfNotExist(entity);
-                    await this.verifyAllColumns(entity);
+                if (!entity.options.sqlExpression) {
+                    if (e.$entityName.toLowerCase().indexOf('from ') < 0) {
+                        await this.createIfNotExist(entity);
+                        await this.verifyAllColumns(entity);
+                    }
                 }
             }
             catch (err) {
@@ -128,41 +130,29 @@ export class PostgresSchemaBuilder {
             `${this.whereTableAndSchema(c, e)}`)
             .then(async (r) => {
             if (r.rows.length == 0) {
-                const sql = await this.createTableScript(entity);
+                let result = '';
+                for (const x of entity.fields) {
+                    if (!shouldNotCreateField(x, e) || isAutoIncrement(x)) {
+                        if (result.length != 0)
+                            result += ',';
+                        result += '\r\n  ';
+                        if (isAutoIncrement(x))
+                            result += e.$dbNameOf(x) + ' serial';
+                        else {
+                            result += postgresColumnSyntax(x, e.$dbNameOf(x));
+                        }
+                        if (x == entity.idMetadata.field)
+                            result += ' primary key';
+                    }
+                }
+                let sql = `CREATE SCHEMA IF NOT EXISTS ${this.schemaOnly(e)};
+CREATE table ${this.schemaAndName(e)} (${result}\r\n)`;
                 if (PostgresSchemaBuilder.logToConsole)
                     console.info(sql);
                 await this.pool.execute(sql);
             }
         });
     }
-    /* @internal*/
-    async getAddColumnScript(entity, field) {
-        let e = await dbNamesOf(entity, this.pool.wrapIdentifier);
-        return (`ALTER table ${this.schemaAndName(e)} ` +
-            `ADD column ${postgresColumnSyntax(field, e.$dbNameOf(field))}`);
-    }
-    /* @internal*/
-    async createTableScript(entity) {
-        let result = '';
-        let e = await dbNamesOf(entity, this.pool.wrapIdentifier);
-        for (const x of entity.fields) {
-            if (!shouldNotCreateField(x, e) || isAutoIncrement(x)) {
-                if (result.length != 0)
-                    result += ',';
-                result += '\r\n  ';
-                if (isAutoIncrement(x))
-                    result += e.$dbNameOf(x) + ' serial';
-                else {
-                    result += postgresColumnSyntax(x, e.$dbNameOf(x));
-                }
-                if (x == entity.idMetadata.field)
-                    result += ' primary key';
-            }
-        }
-        let sql = `CREATE SCHEMA IF NOT EXISTS ${this.schemaOnly(e)};
-CREATE table ${this.schemaAndName(e)} (${result}\r\n)`;
-        return sql;
-    }
     async addColumnIfNotExist(entity, c) {
         let e = await dbNamesOf(entity, this.pool.wrapIdentifier);
         if (shouldNotCreateField(c(entity), e))
@@ -173,7 +163,8 @@ CREATE table ${this.schemaAndName(e)} (${result}\r\n)`;
             if ((await cmd.execute(`SELECT 1 FROM information_schema.columns WHERE ` +
                 `${this.whereTableAndSchema(cmd, e)} ` +
                 `AND column_name=${cmd.param(colName.toLocaleLowerCase())}`)).rows.length == 0) {
-                let sql = await this.getAddColumnScript(entity, c(entity));
+                let sql = `ALTER table ${this.schemaAndName(e)} ` +
+                    `ADD column ${postgresColumnSyntax(c(entity), colName)}`;
                 if (PostgresSchemaBuilder.logToConsole)
                     console.info(sql);
                 await this.pool.execute(sql);

package/esm/remult-knex/index.js

@@ -1,4 +1,4 @@
-import { dbNamesOf, isDbReadonly, shouldCreateEntity, shouldNotCreateField, } from '../src/filter/filter-consumer-bridge-to-sql-request.js';
+import { dbNamesOf, isDbReadonly, shouldNotCreateField, } 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';
@@ -13,36 +13,8 @@ export class KnexDataProvider {
     constructor(knex) {
         this.knex = knex;
     }
-    end() {
-        return this.knex.destroy();
-    }
-    /* @internal */
-    provideMigrationBuilder(builder) {
-        var sb = new KnexSchemaBuilder(this.knex);
-        return {
-            async createTable(entity) {
-                let e = await dbNamesOf(entity, (x) => x);
-                sb.createTableKnexCommand(entity, e)
-                    .toSQL()
-                    .forEach((sql) => builder.addSql(sql.sql));
-            },
-            async addColumn(entity, field) {
-                let e = await dbNamesOf(entity, (x) => x);
-                await sb
-                    .createColumnKnexCommand(e, field, e.$dbNameOf(field))
-                    .toSQL()
-                    .forEach((sql) => builder.addSql(sql.sql));
-            },
-        };
-    }
-    createCommand() {
-        return new KnexBridgeToSQLCommand(this.knex);
-    }
-    execute(sql) {
-        return this.createCommand().execute(sql);
-    }
-    static getDb(dataProvider) {
-        const r = (dataProvider || remultContext.dataProvider);
+    static getDb(remult) {
+        const r = (remult || remultContext).dataProvider;
         if (!r.knex)
             throw 'the data provider is not an KnexDataProvider';
         return r.knex;
@@ -378,9 +350,11 @@ export class KnexSchemaBuilder {
         for (const entity of entities) {
             let e = await dbNamesOf(entity, (x) => x);
             try {
-                if (shouldCreateEntity(entity, e)) {
-                    await this.createIfNotExist(entity);
-                    await this.verifyAllColumns(entity);
+                if (!entity.options.sqlExpression) {
+                    if (e.$entityName.toLowerCase().indexOf('from ') < 0) {
+                        await this.createIfNotExist(entity);
+                        await this.verifyAllColumns(entity);
+                    }
                 }
             }
             catch (err) {
@@ -392,30 +366,27 @@ export class KnexSchemaBuilder {
     async createIfNotExist(entity) {
         const e = await dbNamesOf(entity, (x) => x);
         if (!(await this.knex.schema.hasTable(e.$entityName))) {
-            await logSql(this.createTableKnexCommand(entity, e));
-        }
-    }
-    createTableKnexCommand(entity, e) {
-        let cols = new Map();
-        for (const f of entity.fields) {
-            cols.set(f, {
-                name: e.$dbNameOf(f),
-                readonly: shouldNotCreateField(f, e),
-            });
-        }
-        return this.knex.schema.createTable(e.$entityName, (b) => {
-            for (const x of entity.fields) {
-                if (!cols.get(x).readonly || isAutoIncrement(x)) {
-                    if (isAutoIncrement(x))
-                        b.increments(cols.get(x).name);
-                    else {
-                        buildColumn(x, cols.get(x).name, b, supportsJsonDataStorage(this.knex));
-                        if (x == entity.idMetadata.field)
-                            b.primary([cols.get(x).name]);
+            let cols = new Map();
+            for (const f of entity.fields) {
+                cols.set(f, {
+                    name: e.$dbNameOf(f),
+                    readonly: shouldNotCreateField(f, e),
+                });
+            }
+            await logSql(this.knex.schema.createTable(e.$entityName, (b) => {
+                for (const x of entity.fields) {
+                    if (!cols.get(x).readonly || isAutoIncrement(x)) {
+                        if (isAutoIncrement(x))
+                            b.increments(cols.get(x).name);
+                        else {
+                            buildColumn(x, cols.get(x).name, b, supportsJsonDataStorage(this.knex));
+                            if (x == entity.idMetadata.field)
+                                b.primary([cols.get(x).name]);
+                        }
                     }
                 }
-            }
-        });
+            }));
+        }
     }
     async addColumnIfNotExist(entity, c) {
         let e = await dbNamesOf(entity, (x) => x);
@@ -424,14 +395,11 @@ export class KnexSchemaBuilder {
         let col = c(entity);
         let colName = e.$dbNameOf(col);
         if (!(await this.knex.schema.hasColumn(e.$entityName, colName))) {
-            await logSql(this.createColumnKnexCommand(e, col, colName));
+            await logSql(this.knex.schema.alterTable(e.$entityName, (b) => {
+                buildColumn(col, colName, b, supportsJsonDataStorage(this.knex));
+            }));
         }
     }
-    createColumnKnexCommand(e, col, colName) {
-        return this.knex.schema.alterTable(e.$entityName, (b) => {
-            buildColumn(col, colName, b, supportsJsonDataStorage(this.knex));
-        });
-    }
     async verifyAllColumns(entity) {
         let e = await dbNamesOf(entity, (x) => x);
         try {
@@ -534,59 +502,3 @@ function translateValueAndHandleArrayAndHandleArray(field, val) {
         return JSON.stringify(result);
     return result;
 }
-class KnexBridgeToSQLCommand {
-    source;
-    constructor(source) {
-        this.source = source;
-    }
-    values = [];
-    addParameterAndReturnSqlToken(val) {
-        return this.param(val);
-    }
-    param(val) {
-        if (Array.isArray(val))
-            val = JSON.stringify(val);
-        this.values.push(val);
-        return '?';
-    }
-    async execute(sql) {
-        return await this.source.raw(sql, this.values).then((r) => {
-            switch (this.source.client.config.client) {
-                case 'mysql':
-                case 'mysql2':
-                    return new KnexPostgresBridgeToSQLQueryResult({
-                        fields: r[1],
-                        rows: r[0],
-                    });
-                case 'pg':
-                    return new KnexPostgresBridgeToSQLQueryResult(r);
-                default:
-                case 'better-sqlite3':
-                case 'mssql':
-                    return new KnexPostgresBridgeToSQLQueryResult({
-                        rows: r,
-                    });
-            }
-        });
-    }
-}
-class KnexPostgresBridgeToSQLQueryResult {
-    r;
-    getColumnKeyInResultForIndexInSelect(index) {
-        if (this.r.fields)
-            return this.r.fields[index].name;
-        if (this.rows.length == 0)
-            throw Error('No rows');
-        let i = 0;
-        for (let m in this.rows[0]) {
-            if (i++ == index)
-                return m;
-        }
-        throw Error('index not found');
-    }
-    constructor(r) {
-        this.r = r;
-        this.rows = r.rows;
-    }
-    rows;
-}

package/esm/remult-mongo.js

@@ -16,8 +16,8 @@ export class MongoDataProvider {
     }
     session;
     disableTransactions = false;
-    static getDb(dataProvider) {
-        const r = (dataProvider || remultContext.dataProvider);
+    static getDb(remult) {
+        const r = (remult || remultContext).dataProvider;
         if (!r.db)
             throw 'the data provider is not a MongoDataProvider';
         return { db: r.db, session: r.session };

package/esm/remult-sql-js.js

@@ -1,16 +1,11 @@
 import { SqlDatabase } from './src/data-providers/sql-database.js';
-import { dbNamesOf, shouldNotCreateField, } from './src/filter/filter-consumer-bridge-to-sql-request.js';
+import { dbNamesOf, isDbReadonly, } from './src/filter/filter-consumer-bridge-to-sql-request.js';
 import { isAutoIncrement } from './src/remult3/RepositoryImplementation.js';
 export class SqlJsDataProvider {
     db;
     constructor(db) {
         this.db = db;
     }
-    orderByNullsFirst;
-    async end() {
-        ;
-        (await this.db).close();
-    }
     getLimitSqlSyntax(limit, offset) {
         return ' limit ' + limit + ' offset ' + offset;
     }
@@ -57,7 +52,7 @@ export class SqlJsDataProvider {
         let result = '';
         let e = await dbNamesOf(entity);
         for (const x of entity.fields) {
-            if (!shouldNotCreateField(x, e) || isAutoIncrement(x)) {
+            if (!isDbReadonly(x, e) || isAutoIncrement(x)) {
                 if (result.length != 0)
                     result += ',';
                 result += '\r\n  ';

package/esm/server/expressBridge.js

@@ -13,7 +13,6 @@ import { serverActionField } from '../src/server-action-info.js';
 import { initDataProvider } from './initDataProvider.js';
 import { remultStatic } from '../src/remult-static.js';
 import remultAdminHtml from './remult-admin.js';
-import { isOfType } from '../src/isOfType.js';
 export function createRemultServerCore(options, serverCoreOptions) {
     if (!options) {
         options = {};
@@ -250,8 +249,8 @@ export class RemultServerImplementation {
             console.info('[remult] ' + myRoute);
         r.route(myRoute)
             .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).updateMany(res, req, await this.coreOptions.getRequestBody(orig))))
-            .delete(this.process(async (c, req, res, _, __, orig) => dataApiFactory(c).deleteMany(res, req, undefined)))
+            .put(this.process(async (c, req, res, _, __, orig) => dataApiFactory(c).put(res, '', await this.coreOptions.getRequestBody(orig))))
+            .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, await this.coreOptions.getRequestBody(orig), () => this.serializeContext(c))));
         r.route(myRoute + '/:id')
             //@ts-ignore
@@ -286,7 +285,7 @@ export class RemultServerImplementation {
                     genReq.params = req['_tempParams'];
             }
             let myReq = new ExpressRequestBridgeToDataApiRequest(genReq);
-            let myRes = new ExpressResponseBridgeToDataApiResponse(origRes, req, this.options.error);
+            let myRes = new ExpressResponseBridgeToDataApiResponse(origRes, req);
             try {
                 await this.runWithRemult(async (remult) => {
                     if (req) {
@@ -316,7 +315,7 @@ export class RemultServerImplementation {
                 });
             }
             catch (err) {
-                myRes.error(err, undefined);
+                myRes.error(serializeError(err));
             }
         };
     }
@@ -467,17 +466,6 @@ export class RemultServerImplementation {
                     return secureBase(condition, def, item);
                 };
                 let apiPath = (spec.paths[this.options.rootPath + '/' + key] = {});
-                let itemInBody = {
-                    requestBody: {
-                        content: {
-                            'application/json': {
-                                schema: {
-                                    $ref: '#/components/schemas/' + mutationKey,
-                                },
-                            },
-                        },
-                    },
-                };
                 let apiPathWithId = (spec.paths[this.options.rootPath + '/' + key + '/{id}'] = {});
                 //https://github.com/2fd/open-api.d.ts
                 apiPath.get = secure(meta.options.allowApiRead, true, {
@@ -530,73 +518,6 @@ export class RemultServerImplementation {
                         },
                     },
                 });
-                apiPath.delete = secure(meta.options.allowApiDelete, true, {
-                    description: 'deletes row of ' +
-                        key +
-                        '. supports filter operators. For more info on filtering [see this article](https://remult.dev/docs/rest-api.html#filter)',
-                    parameters: [...parameters],
-                    responses: {
-                        '400': {
-                            description: 'Error: Bad Request',
-                            content: {
-                                'application/json': {
-                                    schema: {
-                                        $ref: '#/components/schemas/InvalidResponse',
-                                    },
-                                },
-                            },
-                        },
-                        '200': {
-                            description: 'returns the number of deleted rows ' + key,
-                            content: {
-                                'application/json': {
-                                    schema: {
-                                        type: 'object',
-                                        properties: {
-                                            deleted: {
-                                                type: 'number',
-                                            },
-                                        },
-                                    },
-                                },
-                            },
-                        },
-                    },
-                });
-                apiPath.put = secure(meta.options.allowApiDelete, true, {
-                    description: 'updates row of ' +
-                        key +
-                        '. supports filter operators. For more info on filtering [see this article](https://remult.dev/docs/rest-api.html#filter)',
-                    parameters: [...parameters],
-                    ...itemInBody,
-                    responses: {
-                        '400': {
-                            description: 'Error: Bad Request',
-                            content: {
-                                'application/json': {
-                                    schema: {
-                                        $ref: '#/components/schemas/InvalidResponse',
-                                    },
-                                },
-                            },
-                        },
-                        '200': {
-                            description: 'returns the number of updated rows ' + key,
-                            content: {
-                                'application/json': {
-                                    schema: {
-                                        type: 'object',
-                                        properties: {
-                                            updated: {
-                                                type: 'number',
-                                            },
-                                        },
-                                    },
-                                },
-                            },
-                        },
-                    },
-                });
                 let idParameter = {
                     name: 'id',
                     in: 'path',
@@ -604,6 +525,17 @@ export class RemultServerImplementation {
                     required: true,
                     schema: { type: 'string' },
                 };
+                let itemInBody = {
+                    requestBody: {
+                        content: {
+                            'application/json': {
+                                schema: {
+                                    $ref: '#/components/schemas/' + mutationKey,
+                                },
+                            },
+                        },
+                    },
+                };
                 apiPath.post = secure(meta.options.allowApiInsert, false, {
                     //"summary": "insert a " + key,
                     //"description": "insert a " + key,
@@ -741,17 +673,15 @@ class ExpressRequestBridgeToDataApiRequest {
 class ExpressResponseBridgeToDataApiResponse {
     r;
     req;
-    handleError;
     forbidden() {
-        this.error({ message: 'Forbidden' }, undefined, 403);
+        this.setStatus(403).end();
     }
     setStatus(status) {
         return this.r.status(status);
     }
-    constructor(r, req, handleError) {
+    constructor(r, req) {
         this.r = r;
         this.req = req;
-        this.handleError = handleError;
     }
     progress(progress) { }
     success(data) {
@@ -764,53 +694,22 @@ class ExpressResponseBridgeToDataApiResponse {
         this.setStatus(204).end();
     }
     notFound() {
-        this.error({ message: 'Forbidden' }, undefined, 404);
+        this.setStatus(404).end();
     }
-    async error(exception, entity, httpStatusCode) {
-        let data = serializeError(exception);
-        if (!httpStatusCode) {
-            if (data.httpStatusCode) {
-                httpStatusCode = data.httpStatusCode;
-            }
-            else if (isOfType(exception, 'isForbiddenError') &&
-                exception.isForbiddenError) {
-                httpStatusCode = 403;
-            }
-            else if (data.modelState) {
-                httpStatusCode = 400;
-            }
-            else {
-                httpStatusCode = 500;
-            }
-        }
-        let responseSent = false;
-        const sendError = (httpStatusCode, body) => {
-            if (responseSent) {
-                throw Error('Error response already sent');
-            }
-            responseSent = true;
-            console.error({
-                message: body.message,
-                httpStatusCode,
-                stack: data.stack?.split('\n'),
-                url: this.req?.url,
-                method: this.req?.method,
-            });
-            this.setStatus(httpStatusCode).json(body);
-        };
-        await this.handleError?.({
-            httpStatusCode,
-            req: this.req,
-            entity,
-            exception,
-            responseBody: data,
-            sendError,
+    error(data) {
+        data = serializeError(data);
+        console.error({
+            message: data.message,
+            stack: data.stack?.split('\n'),
+            url: this.req?.url,
+            method: this.req?.method,
         });
-        if (!responseSent) {
-            sendError(httpStatusCode, data);
-        }
+        this.setStatus(400).json(data);
     }
 }
+function throwError() {
+    throw 'Invalid';
+}
 class inProcessQueueHandler {
     storage;
     constructor(storage) {

package/esm/src/CompoundIdField.js

@@ -22,17 +22,11 @@ export class CompoundIdField {
         return Promise.resolve('');
     }
     getId(instance) {
-        let get = (field) => {
-            return instance[field.key];
-        };
-        if (typeof instance === 'function') {
-            get = instance;
-        }
         let r = '';
         this.fields.forEach((c) => {
             if (r.length > 0)
                 r += ',';
-            r += c.valueConverter.toJson(get(c));
+            r += instance[c.key];
         });
         return r;
     }
@@ -55,7 +49,7 @@ export class CompoundIdField {
         let val = value.toString();
         let id = val.split(',');
         this.fields.forEach((c, i) => {
-            result[c.key] = c.valueConverter.fromJson(id[i]);
+            result[c.key] = id[i];
         });
         return result;
     }