remult 0.22.5 → 0.22.6-exp.2

package/esm/remult-duckdb.js

@@ -0,0 +1,111 @@
+import { SqliteCoreDataProvider } from './remult-sqlite-core.js';
+import { ValueConverters, dbNamesOf, } from './index.js';
+import { shouldNotCreateField } from './src/filter/filter-consumer-bridge-to-sql-request.js';
+import { isAutoIncrement } from './src/remult3/RepositoryImplementation.js';
+export class DuckDBDataProvider extends SqliteCoreDataProvider {
+    constructor(db) {
+        super(() => new DuckDBCommand(db), async () => (await db).close(), false, true);
+    }
+    wrapIdentifier(name) {
+        return `"${name}"`;
+    }
+    async getCreateTableSql(entity) {
+        let result = '';
+        let e = await dbNamesOf(entity, this.wrapIdentifier);
+        let sql = '';
+        for (const x of entity.fields) {
+            if (!shouldNotCreateField(x, e) || isAutoIncrement(x)) {
+                if (result.length != 0)
+                    result += ',';
+                result += '\r\n  ';
+                if (isAutoIncrement(x)) {
+                    const sequenceName = `${entity.dbName}_${x.dbName}_seq`;
+                    sql += `create sequence if not exists "${sequenceName}";\r\n`;
+                    result += `${e.$dbNameOf(x)} integer default nextval('${sequenceName}')`;
+                }
+                else {
+                    result += this.addColumnSqlSyntax(x, e.$dbNameOf(x), false);
+                }
+            }
+        }
+        result += `,\r\n   primary key (${entity.idMetadata.fields
+            .map((f) => e.$dbNameOf(f))
+            .join(',')})`;
+        sql +=
+            'create table if not exists ' + e.$entityName + ' (' + result + '\r\n)';
+        return [sql];
+    }
+    addColumnSqlSyntax(x, dbName, isAlterColumn) {
+        let result = dbName;
+        var allowNull = x.allowNull;
+        if (!allowNull && isAlterColumn) {
+            allowNull = true;
+            console.log('DuckDB does not support altering columns to allow null on existing tables');
+        }
+        if (x.valueType == Number) {
+            if (!x.valueConverter.fieldTypeInDb)
+                result += ' numeric' + (allowNull ? '' : ' default 0 not null');
+            else
+                result +=
+                    ' ' +
+                        x.valueConverter.fieldTypeInDb +
+                        (allowNull ? '' : ' default 0 not null');
+        }
+        else if (x.valueType == Date) {
+            if (!x.valueConverter.fieldTypeInDb)
+                if (x.valueConverter == ValueConverters.DateOnly)
+                    result += ' date';
+                else
+                    result += ' timestamp';
+            else
+                result += ' ' + x.valueConverter.fieldTypeInDb;
+        }
+        else if (x.valueType == Boolean)
+            result += ' boolean' + (allowNull ? '' : ' default false not null');
+        else if (x.valueConverter.fieldTypeInDb) {
+            result += ' ' + x.valueConverter.fieldTypeInDb;
+            if (!allowNull && x.valueConverter.fieldTypeInDb == 'integer') {
+                result += ' default 0 not null';
+            }
+        }
+        else
+            result += ' varchar' + (allowNull ? '' : " default '' not null");
+        return result;
+    }
+}
+class DuckDBCommand {
+    db;
+    values = [];
+    constructor(db) {
+        this.db = db;
+    }
+    async execute(sql) {
+        return new Promise((resolve, error) => {
+            this.db.all(sql, ...this.values, (err, rows) => {
+                if (err)
+                    error(err);
+                else
+                    resolve(new DuckDBSqlResult(rows));
+            });
+        });
+    }
+    addParameterAndReturnSqlToken(val) {
+        return this.param(val);
+    }
+    param(val) {
+        const key = '?';
+        this.values.push(val);
+        return key;
+    }
+}
+class DuckDBSqlResult {
+    result;
+    constructor(result) {
+        this.result = result;
+        this.rows = result;
+    }
+    rows;
+    getColumnKeyInResultForIndexInSelect(index) {
+        return Object.keys(this.result[0])[index];
+    }
+}

package/esm/remult-hapi.js

@@ -0,0 +1,114 @@
+import { createRemultServer, } from './server/index.js';
+import { PassThrough } from 'stream';
+export function remultHapi(options) {
+    const api = createRemultServer(options, {
+        buildGenericRequestInfo: (req) => ({
+            method: req.method,
+            params: req.params,
+            query: req.query,
+            url: req.url.pathname,
+            on: (e, do1) => {
+                req.raw.req.on('close', do1);
+            },
+        }),
+        getRequestBody: async (req) => req.payload,
+    });
+    const routesPlugin = {
+        name: 'remultPlugin',
+        register: async (server) => {
+            function hapiHandler(handler) {
+                return (request, h) => {
+                    return new Promise((res, rej) => {
+                        let status = 200;
+                        let stream;
+                        let r = {
+                            status(statusCode) {
+                                status = statusCode;
+                                return r;
+                            },
+                            end() {
+                                res(h.response().code(status));
+                            },
+                            send(html) {
+                                res(h.response(html).code(status));
+                            },
+                            json(data) {
+                                res(h.response(data).code(status));
+                            },
+                            write(data) {
+                                stream.write(data);
+                            },
+                            writeHead(status, headers) {
+                                stream = new PassThrough();
+                                res(h
+                                    .response(stream)
+                                    .header('content-type', 'text/event-stream')
+                                    .header('content-encoding', 'identity'));
+                            },
+                        };
+                        try {
+                            Object.assign(request, {
+                                on(event, listener) {
+                                    request.raw.req.on('close', () => {
+                                        listener();
+                                        console.log('Connection closed');
+                                    });
+                                },
+                            });
+                            handler(request, r, () => { });
+                        }
+                        catch (err) {
+                            rej(err);
+                        }
+                    });
+                };
+            }
+            let hapiRouter = {
+                route(path) {
+                    path = path.replace(/:id\b/g, '{id}');
+                    let r = {
+                        get(handler) {
+                            server.route({
+                                method: 'GET',
+                                path,
+                                handler: hapiHandler(handler),
+                            });
+                            return r;
+                        },
+                        post(handler) {
+                            server.route({
+                                method: 'POST',
+                                path,
+                                handler: hapiHandler(handler),
+                            });
+                            return r;
+                        },
+                        put(handler) {
+                            server.route({
+                                method: 'PUT',
+                                path,
+                                handler: hapiHandler(handler),
+                            });
+                            return r;
+                        },
+                        delete(handler) {
+                            server.route({
+                                method: 'DELETE',
+                                path,
+                                handler: hapiHandler(handler),
+                            });
+                            return r;
+                        },
+                    };
+                    return r;
+                },
+            };
+            api.registerRouter(hapiRouter);
+        },
+    };
+    return Object.assign(routesPlugin, {
+        getRemult: (x) => api.getRemult(x),
+        openApiDoc: (x) => api.openApiDoc(x),
+        withRemult: (req, what) => api.withRemultAsync(req, what),
+    });
+}

package/esm/remult-hono.js

@@ -0,0 +1,104 @@
+import { Hono } from 'hono';
+import { streamSSE } from 'hono/streaming';
+import { createRemultServer, } from './server/index.js';
+export function remultHono(options) {
+    let app = new Hono();
+    const api = createRemultServer(options, {
+        buildGenericRequestInfo: (c) => {
+            return {
+                method: c.req.method,
+                params: c.req.param(),
+                query: new Proxy(c.req, {
+                    get: (target, prop) => {
+                        const r = c.req.queries(prop);
+                        if (r?.length == 1)
+                            return r[0];
+                        return r;
+                    },
+                }),
+                url: c.req.url,
+                on: (e, do1) => {
+                    ;
+                    c['_tempOnClose'](() => do1());
+                    //   c.req.on('close', do1)
+                },
+            };
+        },
+        getRequestBody: async (c) => {
+            return c.req.json();
+        },
+    });
+    let honoRouter = {
+        route(path) {
+            let r = {
+                get(handler) {
+                    app.get(path, honoHandler(handler));
+                    return r;
+                },
+                post(handler) {
+                    app.post(path, honoHandler(handler));
+                    return r;
+                },
+                put(handler) {
+                    app.put(path, honoHandler(handler));
+                    return r;
+                },
+                delete(handler) {
+                    app.delete(path, honoHandler(handler));
+                    return r;
+                },
+            };
+            return r;
+            function honoHandler(handler) {
+                return (c) => {
+                    return new Promise((res, rej) => {
+                        try {
+                            let result;
+                            let sse;
+                            const gRes = {
+                                json: (data) => {
+                                    res(c.json(data));
+                                },
+                                status: (status) => {
+                                    result = c.status(status);
+                                    return gRes;
+                                },
+                                end: () => {
+                                    if (sse)
+                                        sse.close();
+                                    else
+                                        res(c.body(null));
+                                },
+                                send: (data) => {
+                                    res(c.html(data));
+                                },
+                                write: (data) => {
+                                    sse.write(data);
+                                },
+                                writeHead: (status, headers) => {
+                                    res(streamSSE(c, (s) => {
+                                        sse = s;
+                                        return new Promise((res) => {
+                                            ;
+                                            c['_tempOnClose'] = (x) => sse.onAbort(() => x());
+                                        });
+                                    }));
+                                },
+                            };
+                            handler(c, gRes, () => { });
+                        }
+                        catch (err) {
+                            rej(err);
+                        }
+                    });
+                };
+            }
+        },
+    };
+    api.registerRouter(honoRouter);
+    return Object.assign(app, {
+        getRemult: (c) => api.getRemult(c),
+        openApiDoc: (options) => api.openApiDoc(options),
+        withRemult: async (c, what) => api.withRemultAsync(c, what),
+    });
+}

package/esm/remult-mongo.js

@@ -233,7 +233,7 @@ class FilterConsumerBridgeToMongo {
         this.add(col, val, '$lt');
     }
     containsCaseInsensitive(col, val) {
-        throw 'containsCaseInsensitive not yet implemented';
+        this.add(col, val, '$regex');
         // this.promises.push(col.getDbName().then(colName => {
         //     this.result.push(b => b.whereRaw(
         //         'lower (' + colName + ") like lower ('%" + val.replace(/'/g, '\'\'') + "%')"));

package/esm/remult-nuxt.js

@@ -0,0 +1,54 @@
+import { readBody, setResponseStatus } 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: () => { },
+            send: () => { },
+            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) {
+            if (r.statusCode !== 200)
+                setResponseStatus(event, r.statusCode);
+            if (r.html)
+                return r.html;
+            return r.data;
+        }
+    };
+    return Object.assign(handler, {
+        getRemult: (req) => result.getRemult(req),
+        openApiDoc: (options) => result.openApiDoc(options),
+        withRemult(request, what) {
+            return result.withRemultAsync(request, what);
+        },
+    });
+}

package/esm/remult-solid-start.js

@@ -0,0 +1,97 @@
+import { getRequestEvent } from 'solid-js/web';
+import { createRemultServer } from './server/index.js';
+export function remultSolidStart(options) {
+    let result = createRemultServer(options, {
+        buildGenericRequestInfo: (event) => ({
+            url: event.request.url,
+            method: event.request.method,
+            on: (e, do1) => {
+                if (e === 'close') {
+                    event.locals['_tempOnClose'] = do1;
+                }
+            },
+        }),
+        getRequestBody: (event) => event.request.json(),
+    });
+    const serverHandler = async () => {
+        const event = await getRequestEvent();
+        let sseResponse = undefined;
+        if (event)
+            event.locals['_tempOnClose'] = () => { };
+        const response = {
+            end: () => { },
+            json: () => { },
+            send: () => { },
+            status: () => {
+                return response;
+            },
+            write: () => { },
+            writeHead: (status, headers) => {
+                if (status === 200 && headers) {
+                    const contentType = headers['Content-Type'];
+                    if (contentType === 'text/event-stream') {
+                        const messages = [];
+                        response.write = (x) => messages.push(x);
+                        const stream = new ReadableStream({
+                            start: (controller) => {
+                                for (const message of messages) {
+                                    controller.enqueue(message);
+                                }
+                                response.write = (data) => {
+                                    controller.enqueue(data);
+                                };
+                            },
+                            cancel: () => {
+                                response.write = () => { };
+                                event?.locals?.['_tempOnClose']?.();
+                            },
+                        });
+                        sseResponse = new Response(stream, { headers });
+                    }
+                }
+            },
+        };
+        const responseFromRemultHandler = await result.handle(event, response);
+        if (sseResponse !== undefined) {
+            return sseResponse;
+        }
+        if (responseFromRemultHandler) {
+            if (responseFromRemultHandler.html)
+                return new Response(responseFromRemultHandler.html, {
+                    status: responseFromRemultHandler.statusCode,
+                    headers: {
+                        'Content-Type': 'text/html',
+                    },
+                });
+            const res = new Response(JSON.stringify(responseFromRemultHandler.data), {
+                status: responseFromRemultHandler.statusCode,
+            });
+            return res;
+        }
+        return new Response('Not Found', {
+            status: 404,
+        });
+    };
+    const handler = {}; //async ({ event, resolve }) => {
+    //   if (event.url.pathname.startsWith(options!.rootPath!)) {
+    //     const result = await serverHandler(event)
+    //     if (result != null && result?.status != 404) return result
+    //   }
+    //   return new Promise<Response>((res) => {
+    //     result.withRemult(event, undefined!, async () => {
+    //       res(await resolve(event))
+    //     })
+    //   })
+    // }
+    return Object.assign(handler, {
+        getRemult: (req) => result.getRemult(req),
+        openApiDoc: (options) => result.openApiDoc(options),
+        async withRemult(what) {
+            return result.withRemultAsync(await getRequestEvent(), what);
+        },
+        GET: serverHandler,
+        PUT: serverHandler,
+        POST: serverHandler,
+        DELETE: serverHandler,
+    });
+}

package/esm/remult-sql-js.js

@@ -0,0 +1,41 @@
+import { SqliteCoreDataProvider } from './remult-sqlite-core.js';
+export class SqlJsDataProvider extends SqliteCoreDataProvider {
+    constructor(db) {
+        super(() => new SqlJsCommand(db), async () => (await db).close());
+    }
+}
+class SqlJsCommand {
+    db;
+    values = {};
+    i = 0;
+    constructor(db) {
+        this.db = db;
+    }
+    async execute(sql) {
+        if (this.i == 0)
+            return new SqlJsSqlResult((await this.db).exec(sql));
+        return new SqlJsSqlResult((await this.db).exec(sql, this.values));
+    }
+    addParameterAndReturnSqlToken(val) {
+        return this.param(val);
+    }
+    param(val) {
+        if (val instanceof Date)
+            val = val.valueOf();
+        const key = ':' + ++this.i;
+        this.values[key] = val;
+        return key;
+    }
+}
+class SqlJsSqlResult {
+    result;
+    constructor(result) {
+        this.result = result;
+        this.rows =
+            result[0]?.values.map((row) => row.reduce((prev, curr, i) => ({ ...prev, [result[0].columns[i]]: curr }), {})) ?? [];
+    }
+    rows;
+    getColumnKeyInResultForIndexInSelect(index) {
+        return this.result[0]?.columns[index];
+    }
+}

package/esm/remult-sqlite-core.js

@@ -0,0 +1,137 @@
+import { SqlDatabase } from './src/data-providers/sql-database.js';
+import { dbNamesOf, shouldNotCreateField, } from './src/filter/filter-consumer-bridge-to-sql-request.js';
+import { isAutoIncrement } from './src/remult3/RepositoryImplementation.js';
+export class SqliteCoreDataProvider {
+    createCommand;
+    end;
+    doesNotSupportReturningSyntax;
+    doesNotSupportReturningSyntaxOnlyForUpdate;
+    constructor(createCommand, end, doesNotSupportReturningSyntax = false, doesNotSupportReturningSyntaxOnlyForUpdate = false) {
+        this.createCommand = createCommand;
+        this.end = end;
+        this.doesNotSupportReturningSyntax = doesNotSupportReturningSyntax;
+        this.doesNotSupportReturningSyntaxOnlyForUpdate = doesNotSupportReturningSyntaxOnlyForUpdate;
+    }
+    orderByNullsFirst;
+    getLimitSqlSyntax(limit, offset) {
+        return ' limit ' + limit + ' offset ' + offset;
+    }
+    afterMutation;
+    provideMigrationBuilder(builder) {
+        let self = this;
+        return {
+            createTable: async (entity) => {
+                await (await self.getCreateTableSql(entity)).map(builder.addSql);
+            },
+            addColumn: async (entity, field) => {
+                let e = await dbNamesOf(entity, this.wrapIdentifier);
+                let sql = `alter table ${e.$entityName} add column ${self.addColumnSqlSyntax(field, e.$dbNameOf(field), true)}`;
+                builder.addSql(sql);
+            },
+        };
+    }
+    async transaction(action) {
+        await this.createCommand().execute('Begin Transaction');
+        try {
+            await action(this);
+            await this.createCommand().execute('Commit');
+        }
+        catch (err) {
+            await this.createCommand().execute('Rollback');
+            throw err;
+        }
+    }
+    async entityIsUsedForTheFirstTime(entity) { }
+    async ensureSchema(entities) {
+        for (const entity of entities) {
+            await this.createTableIfNotExist(entity);
+            await this.verifyAllColumns(entity);
+        }
+    }
+    async verifyAllColumns(entity) {
+        try {
+            let cmd = this.createCommand();
+            let e = await dbNamesOf(entity, this.wrapIdentifier);
+            let cols = (await cmd.execute(`PRAGMA table_info(${e.$entityName})`)).rows.map((x) => this.wrapIdentifier(x.name.toLocaleLowerCase()));
+            for (const col of entity.fields) {
+                if (!shouldNotCreateField(col, e)) {
+                    let colName = e.$dbNameOf(col).toLocaleLowerCase();
+                    if (!cols.includes(colName)) {
+                        let sql = `ALTER table ${e.$entityName} ` +
+                            `add column ${this.addColumnSqlSyntax(col, e.$dbNameOf(col), true)}`;
+                        await this.createCommand().execute(sql);
+                    }
+                }
+            }
+        }
+        catch (err) {
+            console.error(err);
+        }
+    }
+    async dropTable(entity) {
+        let e = await dbNamesOf(entity, this.wrapIdentifier);
+        let sql = 'drop  table if exists ' + e.$entityName;
+        if (SqlDatabase.LogToConsole)
+            console.info(sql);
+        await this.createCommand().execute(sql);
+    }
+    addColumnSqlSyntax(x, dbName, isAlterTable) {
+        let result = dbName;
+        const nullNumber = x.allowNull ? '' : ' default 0 not null';
+        if (x.valueType == Date)
+            result += ' integer';
+        else if (x.valueType == Boolean)
+            result += ' integer ' + nullNumber;
+        else if (x.valueType == Number) {
+            if (!x.valueConverter.fieldTypeInDb)
+                result += ' numeric ' + nullNumber;
+            else
+                result += ' ' + x.valueConverter.fieldTypeInDb + ' ' + nullNumber;
+        }
+        else
+            result += ' text' + (x.allowNull ? ' ' : " default '' not null ");
+        return result;
+    }
+    async createTableIfNotExist(entity) {
+        let sql = await this.getCreateTableSql(entity);
+        for (const element of sql) {
+            await this.createCommand().execute(element);
+        }
+    }
+    supportsJsonColumnType;
+    async getCreateTableSql(entity) {
+        let result = '';
+        let e = await dbNamesOf(entity, this.wrapIdentifier);
+        for (const x of entity.fields) {
+            if (!shouldNotCreateField(x, e) || isAutoIncrement(x)) {
+                if (result.length != 0)
+                    result += ',';
+                result += '\r\n  ';
+                if (isAutoIncrement(x)) {
+                    if (x.key != entity.idMetadata.field.key)
+                        throw 'in sqlite, autoincrement is only allowed for primary key';
+                    result += e.$dbNameOf(x) + ' integer primary key autoincrement';
+                }
+                else {
+                    result += this.addColumnSqlSyntax(x, e.$dbNameOf(x), false);
+                    if (x.key == entity.idMetadata.field.key) {
+                        result += ' primary key';
+                    }
+                }
+            }
+        }
+        let sql = [
+            'create table if not exists ' + e.$entityName + ' (' + result + '\r\n)',
+        ];
+        if (entity.idMetadata.fields.length > 1) {
+            sql.push(`create unique index ${this.wrapIdentifier(entity.dbName + '_primary_key')} on ${e.$entityName}  (${entity.idMetadata.fields
+                .map((x) => e.$dbNameOf(x))
+                .join(',')})`);
+        }
+        return sql;
+    }
+    wrapIdentifier(name) {
+        //return name
+        return '`' + name + '`';
+    }
+}