remult 0.22.6-exp.1 → 0.22.6-exp.3

package/async-hooks.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Initializes and enables async context tracking for the server.
+ *
+ * This should be called before handling any incoming requests or calling `withRemult()`.
+ * @example
+ * import { remult, repo, withRemult } from 'remult';
+ * import { initAsyncHooks } from 'remult/async-hooks';
+ *
+ * import { Task } from './entities/Task.js';
+ *
+ * initAsyncHooks();
+ *
+ * // Thx to the `initAsyncHooks` above,
+ * // we have isolated async contexts with multiple `withRemult()`,
+ * // without needing to initialize a `remultApi` all the time!
+ * withRemult(async () => {
+ *     remult.user = { id: '42' };
+ *     repo(Task).find()
+ * });
+ *
+ * withRemult(async () => {
+ *     remult.user = { id: '21' };
+ *     repo(Task).find()
+ * });
+ */
+export declare function initAsyncHooks(): void;

package/async-hooks.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initAsyncHooks = initAsyncHooks;
+var context_js_1 = require("./src/context.js");
+var initAsyncHooks_js_1 = require("./server/initAsyncHooks.js");
+/**
+ * Initializes and enables async context tracking for the server.
+ *
+ * This should be called before handling any incoming requests or calling `withRemult()`.
+ * @example
+ * import { remult, repo, withRemult } from 'remult';
+ * import { initAsyncHooks } from 'remult/async-hooks';
+ *
+ * import { Task } from './entities/Task.js';
+ *
+ * initAsyncHooks();
+ *
+ * // Thx to the `initAsyncHooks` above,
+ * // we have isolated async contexts with multiple `withRemult()`,
+ * // without needing to initialize a `remultApi` all the time!
+ * withRemult(async () => {
+ *     remult.user = { id: '42' };
+ *     repo(Task).find()
+ * });
+ *
+ * withRemult(async () => {
+ *     remult.user = { id: '21' };
+ *     repo(Task).find()
+ * });
+ */
+function initAsyncHooks() {
+    (0, initAsyncHooks_js_1.initAsyncHooks)();
+    context_js_1.RemultAsyncLocalStorage.enable();
+}

package/esm/async-hooks.js

@@ -0,0 +1,31 @@
+import { RemultAsyncLocalStorage } from './src/context.js';
+import { initAsyncHooks as _initAsyncHooks } from './server/initAsyncHooks.js';
+/**
+ * Initializes and enables async context tracking for the server.
+ *
+ * This should be called before handling any incoming requests or calling `withRemult()`.
+ * @example
+ * import { remult, repo, withRemult } from 'remult';
+ * import { initAsyncHooks } from 'remult/async-hooks';
+ *
+ * import { Task } from './entities/Task.js';
+ *
+ * initAsyncHooks();
+ *
+ * // Thx to the `initAsyncHooks` above,
+ * // we have isolated async contexts with multiple `withRemult()`,
+ * // without needing to initialize a `remultApi` all the time!
+ * withRemult(async () => {
+ *     remult.user = { id: '42' };
+ *     repo(Task).find()
+ * });
+ *
+ * withRemult(async () => {
+ *     remult.user = { id: '21' };
+ *     repo(Task).find()
+ * });
+ */
+export function initAsyncHooks() {
+    _initAsyncHooks();
+    RemultAsyncLocalStorage.enable();
+}

package/esm/internals.js

@@ -1,7 +1,9 @@
 import { remultStatic } from './src/remult-static.js';
+export { sqlRelations, sqlRelationsFilter, } from './src/data-providers/sql-relations.js';
 export { getRelationInfo, getRelationFieldInfo, } from './src/remult3/relationInfoMember.js';
-export { decorateColumnSettings, controllerRefImpl, getControllerRef, } from './src/remult3/RepositoryImplementation.js';
+export { decorateColumnSettings, controllerRefImpl, getControllerRef, fieldOptionsEnricher, } from './src/remult3/RepositoryImplementation.js';
 export { getEntitySettings } from './src/remult3/getEntityRef.js';
 export { __updateEntityBasedOnWhere } from './src/filter/filter-interfaces.js';
 export const actionInfo = remultStatic.actionInfo;
+export { isOfType } from './src/isOfType.js';
 export { flags } from './src/remult3/remult3.js';

package/esm/migrations/generate-migrations.js

@@ -36,7 +36,7 @@ export async function generateMigrations(options) {
     const code = {
         //https://marketplace.visualstudio.com/items?itemName=qufiwefefwoyn.inline-sql-syntax
         addSql: (sql) => {
-            steps.push('await sql(`--sql\n' + sql + '`)');
+            steps.push('await sql(`--sql\n' + escapeForTpl(sql) + '`)');
             hasSql = true;
         },
         addTypescriptCode: (code) => steps.push(code),
@@ -66,3 +66,7 @@ export async function generateMigrations(options) {
     }
     return steps.length > 0;
 }
+function escapeForTpl(str) {
+    // escape backticks, dollar-signs and backslashes
+    return str.replace(/[`\\$]/g, (m) => "\\" + m);
+}

package/esm/remult-d1-http.js

@@ -0,0 +1,32 @@
+import Cloudflare from 'cloudflare';
+import { SqlDatabase } from './index.js';
+import { D1DataProvider } from './remult-d1.js';
+export { D1DataProvider };
+export function createD1HttpDataProvider(creds) {
+    return new SqlDatabase(new D1DataProvider(new D1HttpClient(creds)));
+}
+export class D1HttpClient {
+    d1;
+    accountId;
+    databaseId;
+    constructor({ accountId, databaseId, apiToken }) {
+        this.d1 = new Cloudflare({ apiToken }).d1.database;
+        this.accountId = accountId;
+        this.databaseId = databaseId;
+    }
+    async execute(sql, params = []) {
+        return this.d1
+            .query(this.databaseId, {
+            sql,
+            params: params,
+            account_id: this.accountId,
+        })
+            .then(({ result: pages }) => pages.flatMap((page) => page.results));
+        // NOTE: d1 query endpoint returns the result as array of object with keys as column names.
+        // We're returning that now because the rest of remult seems to expect that.
+        // D1 also has a more efficient raw() endpoint that returns {columns: string[], rows: any[][]} that we may want
+        // to use eventually, and write code like fromRowToSql()
+        // at https://github.com/tursodatabase/libsql-client-ts/blob/main/packages/libsql-client/src/sqlite3.ts#L398
+        // to adapt the data
+    }
+}

package/esm/remult-d1.js

@@ -0,0 +1,90 @@
+/// <reference types="@cloudflare/workers-types" />
+import { SqlDatabase, } from './index.js';
+import { SqliteCoreDataProvider } from './remult-sqlite-core.js';
+export function createD1DataProvider(d1) {
+    return new SqlDatabase(new D1DataProvider(new D1BindingClient(d1)));
+}
+export class D1DataProvider extends SqliteCoreDataProvider {
+    d1;
+    /**
+     * For production or local d1 using binding
+     *
+     * const dataProvider = new SqlDatabase(new D1DataProvider(new D1BindingClient(d1)))
+     */
+    constructor(d1) {
+        super(() => new D1Command(this.d1), async () => {
+            // afaik: d1 connection doesn't need closing,
+            // so this is just a noop
+        });
+        this.d1 = d1;
+    }
+    async transaction(action) {
+        // As of June 2025, D1 doesn't support transactions
+        // Here we simply run the action without wrapping it in a transaction
+        // It means queries in action() will be run individually (this is the same decision prisma made)
+        await action(this);
+    }
+}
+export class D1BindingClient {
+    d1;
+    /**
+     * Simple d1 client that wraps the d1 binding directly
+     *
+     * const d1 = new D1BindingClient(env.DB)
+     */
+    constructor(d1) {
+        this.d1 = d1;
+    }
+    async execute(sql, params = []) {
+        // https://developers.cloudflare.com/d1/worker-api/d1-database/
+        // https://developers.cloudflare.com/d1/worker-api/prepared-statements/
+        //
+        // Note: see if we should eventually take advantage of the raw() end point too.
+        const { results } = await this.d1
+            .prepare(sql)
+            .bind(...params)
+            .run();
+        return results;
+    }
+}
+class D1Command {
+    d1;
+    params = [];
+    constructor(d1) {
+        this.d1 = d1;
+    }
+    async execute(sql) {
+        const results = await this.d1.execute(sql, this.params);
+        return new D1SqlResult(results);
+    }
+    /** @deprecated use `param` instead*/
+    addParameterAndReturnSqlToken(val) {
+        return this.param(val);
+    }
+    param(val) {
+        let p;
+        if (val instanceof Date)
+            p = val.valueOf();
+        else if (typeof val === 'boolean')
+            p = val ? 1 : 0;
+        else
+            p = val;
+        this.params.push(p);
+        // According to https://developers.cloudflare.com/d1/worker-api/prepared-statements/
+        // only the ordered "?NNN" and anonymous "?" param types are supported (although :AAAA seems to work too)
+        const key = `?${this.params.length}`;
+        return key;
+    }
+}
+class D1SqlResult {
+    rows;
+    columns;
+    constructor(rows = []) {
+        this.rows = rows;
+        // NOTE: are we guaranteed that when this is reached, rows is not empty?
+        this.columns = rows.length === 0 ? [] : Object.keys(rows[0]);
+    }
+    getColumnKeyInResultForIndexInSelect(index) {
+        return this.columns[index];
+    }
+}

package/esm/remult-duckdb.js

@@ -1,10 +1,13 @@
+import { DuckDBTypeId } from '@duckdb/node-api';
 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);
+    connection;
+    constructor(connection) {
+        super(() => new DuckDBCommand(this.connection), async () => this.connection.disconnectSync(), false, true);
+        this.connection = connection;
     }
     wrapIdentifier(name) {
         return `"${name}"`;
@@ -12,7 +15,8 @@ export class DuckDBDataProvider extends SqliteCoreDataProvider {
     async getCreateTableSql(entity) {
         let result = '';
         let e = await dbNamesOf(entity, this.wrapIdentifier);
-        let sql = '';
+        const createSequenceStatements = [];
+        let createTableSql = '';
         for (const x of entity.fields) {
             if (!shouldNotCreateField(x, e) || isAutoIncrement(x)) {
                 if (result.length != 0)
@@ -20,7 +24,7 @@ export class DuckDBDataProvider extends SqliteCoreDataProvider {
                 result += '\r\n  ';
                 if (isAutoIncrement(x)) {
                     const sequenceName = `${entity.dbName}_${x.dbName}_seq`;
-                    sql += `create sequence if not exists "${sequenceName}";\r\n`;
+                    createSequenceStatements.push(`create sequence if not exists "${sequenceName}";`);
                     result += `${e.$dbNameOf(x)} integer default nextval('${sequenceName}')`;
                 }
                 else {
@@ -31,15 +35,15 @@ export class DuckDBDataProvider extends SqliteCoreDataProvider {
         result += `,\r\n   primary key (${entity.idMetadata.fields
             .map((f) => e.$dbNameOf(f))
             .join(',')})`;
-        sql +=
+        createTableSql =
             'create table if not exists ' + e.$entityName + ' (' + result + '\r\n)';
-        return sql;
+        return [...createSequenceStatements, createTableSql];
     }
     addColumnSqlSyntax(x, dbName, isAlterColumn) {
         let result = dbName;
         var allowNull = x.allowNull;
-        if (allowNull && isAlterColumn) {
-            allowNull = false;
+        if (!allowNull && isAlterColumn) {
+            allowNull = true;
             console.log('DuckDB does not support altering columns to allow null on existing tables');
         }
         if (x.valueType == Number) {
@@ -49,7 +53,7 @@ export class DuckDBDataProvider extends SqliteCoreDataProvider {
                 result +=
                     ' ' +
                         x.valueConverter.fieldTypeInDb +
-                        (x.allowNull || isAlterColumn ? '' : ' default 0 not null');
+                        (allowNull ? '' : ' default 0 not null');
         }
         else if (x.valueType == Date) {
             if (!x.valueConverter.fieldTypeInDb)
@@ -61,56 +65,96 @@ export class DuckDBDataProvider extends SqliteCoreDataProvider {
                 result += ' ' + x.valueConverter.fieldTypeInDb;
         }
         else if (x.valueType == Boolean)
-            result +=
-                ' boolean' +
-                    (x.allowNull || isAlterColumn ? '' : ' default false not null');
+            result += ' boolean' + (allowNull ? '' : ' default false not null');
         else if (x.valueConverter.fieldTypeInDb) {
             result += ' ' + x.valueConverter.fieldTypeInDb;
-            if (!(x.allowNull || isAlterColumn) &&
-                x.valueConverter.fieldTypeInDb == 'integer') {
+            if (!allowNull && x.valueConverter.fieldTypeInDb == 'integer') {
                 result += ' default 0 not null';
             }
         }
         else
-            result +=
-                ' varchar' +
-                    (x.allowNull || isAlterColumn ? '' : " default '' not null");
+            result += ' varchar' + (allowNull ? '' : " default '' not null");
         return result;
     }
 }
 class DuckDBCommand {
-    db;
+    connection;
     values = [];
-    constructor(db) {
-        this.db = db;
+    constructor(connection) {
+        this.connection = connection;
     }
     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));
-            });
-        });
+        try {
+            const result = await this.connection.run(sql, this.values);
+            this.values = [];
+            return new DuckDBSqlResult(result);
+        }
+        catch (err) {
+            this.values = [];
+            throw err;
+        }
+    }
+    addParamInternal(val) {
+        if (val === undefined) {
+            this.values.push(null);
+        }
+        else if (val instanceof Date) {
+            this.values.push(val.toISOString());
+        }
+        else {
+            this.values.push(val);
+        }
+        return '?';
     }
     addParameterAndReturnSqlToken(val) {
-        return this.param(val);
+        return this.addParamInternal(val);
     }
     param(val) {
-        const key = '?';
-        this.values.push(val);
-        return key;
+        return this.addParamInternal(val);
     }
 }
 class DuckDBSqlResult {
-    result;
-    constructor(result) {
-        this.result = result;
-        this.rows = result;
-    }
+    duckDbResult;
     rows;
+    constructor(duckDbResult) {
+        this.duckDbResult = duckDbResult;
+        this.rows = [];
+        const columnNames = this.duckDbResult.columnNames();
+        const columnTypes = this.duckDbResult.columnTypes();
+        const chunkCount = this.duckDbResult.chunkCount;
+        for (let i = 0; i < chunkCount; i++) {
+            const chunk = this.duckDbResult.getChunk(i);
+            const chunkRowObjects = chunk.getRowObjects(columnNames).map((row) => {
+                const convertedRow = {};
+                columnNames.forEach((colName, colIndex) => {
+                    const value = row[colName];
+                    if (value === null) {
+                        convertedRow[colName] = null;
+                    }
+                    else {
+                        const colType = columnTypes[colIndex];
+                        const typeId = colType.typeId;
+                        if (typeId === DuckDBTypeId.TIMESTAMP) {
+                            const timestampValue = value;
+                            const parts = timestampValue.toParts();
+                            convertedRow[colName] = new Date(Date.UTC(parts.date.year, parts.date.month - 1, parts.date.day, parts.time.hour, parts.time.min, parts.time.sec, Math.floor(parts.time.micros / 1000)));
+                        }
+                        else if (typeId === DuckDBTypeId.DATE) {
+                            const dateValue = value;
+                            const parts = dateValue.toParts();
+                            convertedRow[colName] = new Date(Date.UTC(parts.year, parts.month - 1, parts.day));
+                        }
+                        else {
+                            convertedRow[colName] = value;
+                        }
+                    }
+                });
+                return convertedRow;
+            });
+            this.rows.push(...chunkRowObjects);
+        }
+    }
     getColumnKeyInResultForIndexInSelect(index) {
-        return Object.keys(this.result[0])[index];
+        return this.duckDbResult.columnName(index);
     }
 }

package/esm/remult-hapi.js

@@ -1,15 +1,16 @@
 import { createRemultServer, } from './server/index.js';
 import { PassThrough } from 'stream';
-export function remultHapi(options) {
+export function remultApi(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);
+            internal: {
+                ...req,
+                url: req.url.pathname,
+                on: (e, do1) => {
+                    req.raw.req.on('close', do1);
+                },
             },
+            public: { headers: new Headers(req.headers) },
         }),
         getRequestBody: async (req) => req.payload,
     });
@@ -33,7 +34,7 @@ export function remultHapi(options) {
                                 res(h.response(html).code(status));
                             },
                             json(data) {
-                                res(h.response(data).code(status));
+                                res(h.response(data === null ? 'null' : data).code(status));
                             },
                             write(data) {
                                 stream.write(data);
@@ -112,3 +113,5 @@ export function remultHapi(options) {
         withRemult: (req, what) => api.withRemultAsync(req, what),
     });
 }
+/** @deprecated use remultApi instead */
+export const remultHapi = remultApi;

package/esm/remult-hono.js

@@ -1,27 +1,29 @@
 import { Hono } from 'hono';
 import { streamSSE } from 'hono/streaming';
 import { createRemultServer, } from './server/index.js';
-export function remultHono(options) {
+export function remultApi(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;
+                internal: {
+                    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());
                     },
-                }),
-                url: c.req.url,
-                on: (e, do1) => {
-                    ;
-                    c['_tempOnClose'](() => do1());
-                    //   c.req.on('close', do1)
                 },
+                public: { headers: new Headers(c.req.header()) },
             };
         },
         getRequestBody: async (c) => {
@@ -102,3 +104,5 @@ export function remultHono(options) {
         withRemult: async (c, what) => api.withRemultAsync(c, what),
     });
 }
+/** @deprecated use remultApi instead */
+export const remultHono = remultApi;

package/esm/remult-nuxt.js

@@ -1,16 +1,19 @@
 import { readBody, setResponseStatus } from 'h3';
 import { createRemultServer } from './server/index.js';
-export function remultNuxt(options) {
+export function remultApi(options) {
     const result = createRemultServer(options, {
-        buildGenericRequestInfo: (event) => {
-            return {
+        buildGenericRequestInfo: (event) => ({
+            internal: {
                 method: event.node.req.method,
                 url: event.node.req.url,
                 on: (a, b) => event.node.req.on('close', () => {
                     b();
                 }),
-            };
-        },
+            },
+            public: {
+                headers: new Headers(event.node.req.headers),
+            },
+        }),
         getRequestBody: async (event) => await readBody(event),
     });
     const handler = async (event) => {
@@ -41,7 +44,7 @@ export function remultNuxt(options) {
                 setResponseStatus(event, r.statusCode);
             if (r.html)
                 return r.html;
-            return r.data;
+            return r.data == null ? 'null' : r.data;
         }
     };
     return Object.assign(handler, {
@@ -52,3 +55,5 @@ export function remultNuxt(options) {
         },
     });
 }
+/** @deprecated use remultApi instead */
+export const remultNuxt = remultApi;

package/esm/remult-solid-start.js

@@ -1,15 +1,18 @@
 import { getRequestEvent } from 'solid-js/web';
 import { createRemultServer } from './server/index.js';
-export function remultSolidStart(options) {
+export function remultApi(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;
-                }
+            internal: {
+                url: event.request.url,
+                method: event.request.method,
+                on: (e, do1) => {
+                    if (e === 'close') {
+                        event.locals['_tempOnClose'] = do1;
+                    }
+                },
             },
+            public: { headers: new Headers(event.request.headers) },
         }),
         getRequestBody: (event) => event.request.json(),
     });
@@ -95,3 +98,5 @@ export function remultSolidStart(options) {
         DELETE: serverHandler,
     });
 }
+/** @deprecated use remultApi instead */
+export const remultSolidStart = remultApi;

package/esm/remult-sqlite-core.js

@@ -21,7 +21,7 @@ export class SqliteCoreDataProvider {
         let self = this;
         return {
             createTable: async (entity) => {
-                builder.addSql(await self.getCreateTableSql(entity));
+                await (await self.getCreateTableSql(entity)).map(builder.addSql);
             },
             addColumn: async (entity, field) => {
                 let e = await dbNamesOf(entity, this.wrapIdentifier);
@@ -45,6 +45,27 @@ export class SqliteCoreDataProvider {
     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) {
@@ -73,9 +94,9 @@ export class SqliteCoreDataProvider {
     }
     async createTableIfNotExist(entity) {
         let sql = await this.getCreateTableSql(entity);
-        if (SqlDatabase.LogToConsole)
-            console.log(sql);
-        await this.createCommand().execute(sql);
+        for (const element of sql) {
+            await this.createCommand().execute(element);
+        }
     }
     supportsJsonColumnType;
     async getCreateTableSql(entity) {
@@ -99,7 +120,14 @@ export class SqliteCoreDataProvider {
                 }
             }
         }
-        let sql = 'create table if not exists ' + e.$entityName + ' (' + result + '\r\n)';
+        let sql = [
+            'create table if not exists ' + e.$entityName + ' (' + result + '\r\n)',
+        ];
+        if (entity.idMetadata.fields.length > 1) {
+            sql.push(`create unique index if not exists ${this.wrapIdentifier(entity.dbName + '_primary_key')} on ${e.$entityName}  (${entity.idMetadata.fields
+                .map((x) => e.$dbNameOf(x))
+                .join(',')})`);
+        }
         return sql;
     }
     wrapIdentifier(name) {