remult 3.0.6-next.0 → 3.0.6

package/esm/graphql.js

@@ -479,7 +479,7 @@ export function remultGraphql(options) {
                             currentType.fields.push({
                                 key: f.key,
                                 value: `${getMetaType(ref)}${f.allowNull ? '' : '!'}`,
-                                comment: f.caption,
+                                comment: f.label,
                             });
                             currentType.query.resultProcessors.push((r, orig) => {
                                 r[f.key] = async (args, req, gqlInfo) => {
@@ -524,7 +524,7 @@ export function remultGraphql(options) {
                     currentType.fields.push({
                         key: f.key,
                         value: `${getMetaType(ref)}${f.allowNull ? '' : '!'}`,
-                        comment: f.caption,
+                        comment: f.label,
                     });
                     const refKey = ref.key;
                     currentType.query.resultProcessors.push((r) => {
@@ -566,7 +566,7 @@ export function remultGraphql(options) {
                     currentType.fields.push({
                         key: f.key,
                         value: `${type}${f.allowNull ? '' : '!'}`,
-                        comment: f.caption,
+                        comment: f.label,
                     });
                 }
                 // sorting

package/esm/index.js

@@ -1,5 +1,11 @@
 export { ArrayEntityDataProvider } from './src/data-providers/array-entity-data-provider.js';
-export { EntityBase, ControllerBase, FieldType, getFields, ValueListFieldType, getValueList, ValueListInfo, CaptionTransformer, } from './src/remult3/RepositoryImplementation.js';
+export { EntityBase, ControllerBase, FieldType, getFields, ValueListFieldType, getValueList, ValueListInfo, } from './src/remult3/RepositoryImplementation.js';
+import { LabelTransformer } from './src/remult3/RepositoryImplementation.js';
+export { LabelTransformer } from './src/remult3/RepositoryImplementation.js';
+/**
+ * @deprecated use `LabelTransformer` instead
+ */
+export const CaptionTransformer = LabelTransformer;
 export { Entity } from './src/remult3/entity.js';
 export { getEntityRef } from './src/remult3/getEntityRef.js';
 export { Field, Fields, Relations, } from './src/remult3/Fields.js';

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-express.js

@@ -13,7 +13,10 @@ export function remultApi(options) {
         app.use(express.urlencoded({ extended: true, limit: options.bodySizeLimit }));
     }
     const server = createRemultServer(options, {
-        buildGenericRequestInfo: (req) => req,
+        buildGenericRequestInfo: (req) => ({
+            internal: { ...req, on: req.on },
+            public: { headers: new Headers(req.headers) },
+        }),
         getRequestBody: async (req) => req.body,
     });
     server.registerRouter(app);

package/esm/remult-fastify.js

@@ -33,7 +33,15 @@ export function remultApi(options) {
         return response;
     }
     const api = createRemultServer(options, {
-        buildGenericRequestInfo: (req) => req,
+        buildGenericRequestInfo: (req) => ({
+            internal: {
+                ...req,
+                url: req.originalUrl,
+                // @ts-ignore
+                on: req.on,
+            },
+            public: { headers: new Headers(req.headers) },
+        }),
         getRequestBody: async (req) => req.body,
     });
     const pluginFunction = async (instance, op) => {

package/esm/remult-fresh.js

@@ -1,7 +1,11 @@
 import { createRemultServerCore } from './server/remult-api-server.js';
 export function remultApi(options, response) {
     const server = createRemultServerCore(options, {
-        buildGenericRequestInfo: (r) => r,
+        buildGenericRequestInfo: (r) => ({
+            // @ts-ignore
+            internal: { ...r, on: r.on },
+            public: { headers: r.headers },
+        }),
         getRequestBody: (req) => req.json(),
     });
     return {

package/esm/remult-hapi.js

@@ -3,13 +3,14 @@ import { PassThrough } from 'stream';
 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,
     });

package/esm/remult-hono.js

@@ -6,22 +6,24 @@ export function remultApi(options) {
     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) => {

package/esm/remult-next.js

@@ -1,7 +1,10 @@
 import { createRemultServer } from './server/index.js';
 export function remultNext(options) {
     let result = createRemultServer(options, {
-        buildGenericRequestInfo: (req) => req,
+        buildGenericRequestInfo: (req) => ({
+            internal: { ...req, on: req.on },
+            public: { headers: new Headers(req.headers) },
+        }),
         getRequestBody: async (req) => req.body,
     });
     return Object.assign((req, res) => result.handle(req, res).then(() => { }), result, {
@@ -41,14 +44,17 @@ export function remultApi(options) {
     let result = createRemultServer(options, {
         getRequestBody: (req) => req.json(),
         buildGenericRequestInfo: (req) => ({
-            url: req?.url,
-            method: req?.method,
-            on: (e, do1) => {
-                if (e === 'close') {
-                    ;
-                    req['_tempOnClose'] = do1;
-                }
+            internal: {
+                url: req?.url,
+                method: req?.method,
+                on: (e, do1) => {
+                    if (e === 'close') {
+                        ;
+                        req['_tempOnClose'] = do1;
+                    }
+                },
             },
+            public: { headers: req.headers },
         }),
     });
     const handler = async (req) => {

package/esm/remult-nuxt.js

@@ -2,15 +2,18 @@ import { readBody, setResponseStatus } from 'h3';
 import { createRemultServer } from './server/index.js';
 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) => {

package/esm/remult-solid-start.js

@@ -3,13 +3,16 @@ import { createRemultServer } from './server/index.js';
 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(),
     });

package/esm/remult-sveltekit.js

@@ -2,14 +2,17 @@ import { createRemultServer } from './server/index.js';
 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: event.request.headers },
         }),
         getRequestBody: (event) => event.request.json(),
     });
@@ -65,7 +68,7 @@ export function remultApi(options) {
                 status: responseFromRemultHandler.statusCode,
                 headers: {
                     'Content-Type': 'application/json',
-                }
+                },
             });
             return res;
         }

package/esm/server/index.js

@@ -9,7 +9,10 @@ export { Module } from './module.js';
 export function createRemultServer(options, serverCoreOptions) {
     initAsyncHooks();
     return createRemultServerCore(options, serverCoreOptions || {
-        buildGenericRequestInfo: (req) => cast(req, 'method'),
+        buildGenericRequestInfo: (req) => ({
+            internal: cast(req, 'method'),
+            public: { headers: new Headers(req.headers) },
+        }),
         getRequestBody: async (req) => req.body,
     });
 }

package/esm/server/module.js

@@ -11,8 +11,8 @@ export class Module {
         this.priority = options.priority ?? 0;
         this.entities = options.entities;
         this.controllers = options.controllers;
-        this.initRequest = options.initRequest;
         this.initApi = options.initApi;
+        this.initRequest = options.initRequest;
         this.modules = options.modules;
     }
 }

package/esm/server/remult-admin.js

@@ -8,7 +8,11 @@ export default function remultAdminHtml(options) {
     return getHtml()
         .replace('<!--PLACE_HERE_HEAD-->', head)
         .replace('<!--PLACE_HERE_BODY-->', `<script>
-  window.optionsFromServer = ${JSON.stringify({ rootPath, requireAuthToken, disableLiveQuery })}
+  window.optionsFromServer = ${JSON.stringify({
+        rootPath,
+        requireAuthToken,
+        disableLiveQuery,
+    })}
 </script>`);
 }
 export function buildEntityInfo(options) {
@@ -63,7 +67,7 @@ export function buildEntityInfo(options) {
                                 where,
                                 entityKey: relRepo.metadata.key,
                                 key: x.key,
-                                caption: x.caption,
+                                caption: x.label,
                             });
                         }
                         continue;
@@ -74,7 +78,7 @@ export function buildEntityInfo(options) {
                     readOnly: !x.apiUpdateAllowed(),
                     values: getValueList(x),
                     valFieldKey,
-                    caption: x.caption,
+                    caption: x.label,
                     relationToOne: relation,
                     inputType: x.inputType,
                     type: x.inputType === InputTypes.json
@@ -95,11 +99,11 @@ export function buildEntityInfo(options) {
         }
         if (metadata.apiReadAllowed) {
             let superKey = metadata.key;
-            let caption = metadata.caption;
+            let caption = metadata.label;
             const nbOfEntities = entities.filter((e) => e.key === metadata.key).length;
             if (nbOfEntities > 0) {
                 superKey = metadata.key + '_ext_' + nbOfEntities;
-                caption = metadata.caption + '*'.repeat(nbOfEntities);
+                caption = metadata.label + '*'.repeat(nbOfEntities);
             }
             entities.push({
                 superKey,

package/esm/server/remult-api-server.js

@@ -339,7 +339,9 @@ export class RemultServerImplementation {
     }
     process(what, doNotReuseInitRequest) {
         return async (req, origRes) => {
-            const genReq = req ? this.coreOptions.buildGenericRequestInfo(req) : {};
+            const { internal: genReq, public: genReqPublic, } = req
+                ? this.coreOptions.buildGenericRequestInfo(req)
+                : { internal: {}, public: { headers: new Headers() } };
             if (req) {
                 if (!genReq.query) {
                     genReq.query = req['_tempQuery'];
@@ -358,6 +360,16 @@ export class RemultServerImplementation {
                         if (req) {
                             ;
                             remult.context.request = req;
+                            remult.context.headers = {
+                                get: (key) => genReqPublic.headers.get(key) ?? undefined,
+                                getAll: () => {
+                                    const result = {};
+                                    genReqPublic.headers.forEach((value, key) => {
+                                        result[key] = value;
+                                    });
+                                    return result;
+                                },
+                            };
                             remultStatic.asyncContext.setInInitRequest(true);
                             try {
                                 let user;
@@ -1109,7 +1121,7 @@ export class RouteImplementation {
         });
     }
     middleware(origReq, res, next) {
-        const req = this.coreOptions.buildGenericRequestInfo(origReq);
+        const { internal: req } = this.coreOptions.buildGenericRequestInfo(origReq);
         let theUrl = req.url?.toString() || '';
         if (theUrl.startsWith('/'))
             //next sends a partial url '/api/tasks' and not the full url

package/esm/server/test-api-data-provider.js

@@ -11,7 +11,10 @@ export function TestApiDataProvider(options) {
     });
     const server = createRemultServerCore({ ...options, dataProvider: dp }, {
         getRequestBody: async (req) => req.body,
-        buildGenericRequestInfo: (req) => req,
+        buildGenericRequestInfo: (req) => ({
+            internal: req,
+            public: { headers: new Headers() },
+        }),
         ignoreAsyncStorage: true,
     });
     const lock = new AsyncLock();

package/esm/src/CompoundIdField.js

@@ -46,6 +46,7 @@ export class CompoundIdField {
     dbReadOnly = false;
     isServerExpression = false;
     key = '';
+    label = '';
     caption = '';
     inputType = '';
     dbName = '';

package/esm/src/context.js

@@ -231,7 +231,15 @@ export class Remult {
     }
     /** A helper callback that is called whenever an entity is created. */
     static entityRefInit;
-    /** context information that can be used to store custom information that will be disposed as part of the `remult` object */
+    /**
+     * context that can be used to store custom information that will be disposed as part of the `remult` object.
+     *
+     * `remult.context` is pre-filled in a framework-agnostic way with:
+     *   - `headers.get(key: string)` _of request_
+     *   - `headers.getAll()` _of request_
+     *
+     * Check out the [extensibility section](/docs/custom-options#enhancing-field-and-entity-definitions-with-custom-options) for more custom options.
+     */
     context = {};
     /** The api client that will be used by `remult` to perform calls to the `api` */
     apiClient = {

package/esm/src/remult-static.js

@@ -19,7 +19,7 @@ let x = {
         }),
     },
     fieldOptionsEnricher: undefined,
-    captionTransformer: undefined,
+    labelTransformer: undefined,
     defaultDataProvider: () => undefined,
 };
 if ((typeof process !== 'undefined' &&