remult 3.0.6-next.1 → 3.0.7-next.0

package/README.md

@@ -76,7 +76,7 @@ import { Entity, Fields } from 'remult'
   allowApiCrud: true,
 })
 export class Product {
-  @Fields.cuid()
+  @Fields.id()
   id = ''
 
   @Fields.string()
@@ -166,7 +166,7 @@ import { Entity, Fields, Validators } from 'remult'
   allowApiCrud: true,
 })
 export class Product {
-  @Fields.cuid()
+  @Fields.id()
   id = ''
 
   @Fields.string({

package/async-hooks.d.ts

@@ -1 +1,26 @@
-export { 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 declare function initAsyncHooks(): void;

package/async-hooks.js

@@ -1,5 +1,34 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.initAsyncHooks = void 0;
+exports.initAsyncHooks = initAsyncHooks;
+var context_js_1 = require("./src/context.js");
 var initAsyncHooks_js_1 = require("./server/initAsyncHooks.js");
-Object.defineProperty(exports, "initAsyncHooks", { enumerable: true, get: function () { return initAsyncHooks_js_1.initAsyncHooks; } });
+/**
+ * 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

@@ -1 +1,31 @@
-export { initAsyncHooks } from './server/initAsyncHooks.js';
+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/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

@@ -8,15 +8,24 @@ export function remultApi(options) {
     if (options.bodySizeLimit === undefined) {
         options.bodySizeLimit = '10mb';
     }
+    const expressVersion = typeof app.del === 'function' ? 4 : 5;
     if (options?.bodyParser !== false) {
         app.use(express.json({ limit: options.bodySizeLimit }));
         app.use(express.urlencoded({ extended: true, limit: options.bodySizeLimit }));
     }
     const server = createRemultServer(options, {
-        buildGenericRequestInfo: (req) => ({
-            internal: { ...req, on: req.on },
-            public: { headers: new Headers(req.headers) },
-        }),
+        buildGenericRequestInfo: (req) => {
+            const internal = { ...req, on: req.on };
+            if (expressVersion === 5) {
+                if (!internal.query) {
+                    internal.query = req.query;
+                }
+            }
+            return {
+                internal,
+                public: { headers: new Headers(req.headers) },
+            };
+        },
         getRequestBody: async (req) => req.body,
     });
     server.registerRouter(app);