remult 3.0.6 → 3.1.0-next.1

package/esm/server/initAsyncHooks.js

@@ -2,31 +2,6 @@ import { AsyncLocalStorage } from 'async_hooks';
 import { RemultAsyncLocalStorage, } from '../src/context.js';
 import { remultStatic } from '../src/remult-static.js';
 let init = false;
-/**
- * Initializes 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() {
     if (init)
         return;

package/esm/src/live-query/SubscriptionChannel.js

@@ -1,4 +1,3 @@
-import { v4 as uuid } from 'uuid';
 import { Sort } from '../sort.js';
 import { remult as defaultRemult } from '../remult-proxy.js';
 import { getRepositoryInternals } from '../remult3/repository-internals.js';
@@ -92,7 +91,7 @@ export class LiveQuerySubscriber {
     }
     defaultQueryState = [];
     listeners = [];
-    id = uuid();
+    id = String(crypto.randomUUID());
     constructor(repo, query, userId) {
         this.repo = repo;
         this.query = query;

package/esm/src/remult-static.js

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

package/esm/src/remult3/Fields.js

@@ -1,5 +1,3 @@
-import { createId } from '@paralleldrive/cuid2';
-import { v4 as uuid } from 'uuid';
 import { ValueConverters } from '../valueConverters.js';
 import { buildOptions, fieldOptionalValuesFunctionKey, } from './RepositoryImplementation.js';
 import { Validators, createValueValidator, getEnumValues, } from '../validators.js';
@@ -79,43 +77,62 @@ export class Fields {
             },
         }, ...options);
     }
+    /** @deprecated use `@Fields.id()` instead */
     static uuid(...options) {
-        return Field(() => String, {
-            allowApiUpdate: false,
-            defaultValue: () => uuid(),
-            saving: (_, r) => {
-                if (!r.value)
-                    r.value = uuid();
-            },
-        }, ...options);
+        return Fields.id({
+            idFactory: () => crypto.randomUUID(),
+            ...options,
+        });
+    }
+    static _defaultIdFactory = () => crypto.randomUUID();
+    static get defaultIdFactory() {
+        return this._defaultIdFactory;
+    }
+    static set defaultIdFactory(value) {
+        this._defaultIdFactory = value;
+        remultStatic.defaultIdFactory = value;
     }
     /**
-     * A CUID (Collision Resistant Unique Identifier) field.
-     * This id value is determined on the backend on insert, and can't be updated through the API.
-     * The CUID is generated using the `@paralleldrive/cuid2` npm package.
+     * Defines a field that will be used as the id of the entity.
+     * By default it will use `crypto.randomUUID` to generate the id.
+     *
+     * You can change the algorithm used to generate the id by setting the `Fields.defaultIdFactory`
+     * to a different function like:
+     *
+     * This needs to be done in a shared file to be accessible frontend and backend.
+     *
+     * ```ts
+     * import { createId } from '@paralleldrive/cuid2'
+     * Fields.defaultIdFactory = () => createId()
+     * ```
+     *
+     * You can also pass an id factory as an option to the `@Fields.id` to have a different value locally.
+     * @example
+     * ```ts
+     * import { createId } from '@paralleldrive/cuid2'
+     * // import { v4 as uuid } from 'uuid'
+     *
+     * class MyEntity {
+     *   \@Fields.id({
+     *     idFactory: () => createId()
+     *     // idFactory: () => uuid()
+     *   })
+     *   id: string = '';
+     * }
+     * ```
      */
-    static cuid(...options) {
+    static id(options) {
+        let idFactory = options?.idFactory ?? remultStatic.defaultIdFactory;
         return Field(() => String, {
             allowApiUpdate: false,
-            defaultValue: () => createId(),
+            defaultValue: () => idFactory(),
             saving: (_, r) => {
                 if (!r.value)
-                    r.value = createId();
+                    r.value = idFactory();
             },
-        }, ...options);
+            ...options,
+        });
     }
-    // static id<entityType = unknown>(
-    //   options?: FieldOptions<entityType, string> & { idFactory?: () => string },
-    // ): ClassFieldDecorator<entityType, string | undefined> {
-    //   let buildId = options?.idFactory ?? createId
-    //   return Field(() => String, {
-    //     allowApiUpdate: false,
-    //     defaultValue: () => buildId(),
-    //     saving: (_, r) => {
-    //       if (!r.value) r.value = buildId()
-    //     },
-    //   })
-    // }
     /**
    * Defines a field that can hold a value from a specified set of string literals.
    * @param {() => readonly valueType[]} optionalValues - A function that returns an array of allowed string literals.
@@ -185,6 +202,8 @@ export class Fields {
         return Field(() => Boolean, ...options);
     }
 }
+// Initialize remultStatic.defaultIdFactory with the default value
+remultStatic.defaultIdFactory = Fields.defaultIdFactory;
 export class Relations {
     /**
      * Define a to-one relation between entities, indicating a one-to-one relationship.
@@ -302,10 +321,12 @@ export function Field(valueType, ...options) {
                 r.dbName = r.key;
             let type = r.valueType;
             if (!type) {
-                type =
-                    typeof Reflect.getMetadata == 'function'
-                        ? Reflect.getMetadata('design:type', target, key)
-                        : [];
+                // removing import 'reflect-metadata' from server-action.ts, so we return an empty array
+                type = undefined;
+                // type =
+                //   typeof Reflect.getMetadata == 'function'
+                //     ? Reflect.getMetadata('design:type', target, key)
+                //     : []
                 r.valueType = type;
             }
             if (!r.target)

package/esm/src/remult3/IdEntity.js

@@ -5,6 +5,6 @@ export class IdEntity extends EntityBase {
     id;
 }
 __decorate([
-    Fields.uuid(),
+    Fields.id(),
     __metadata("design:type", String)
 ], IdEntity.prototype, "id", void 0);

package/esm/src/remult3/entity.js

@@ -9,7 +9,7 @@ import { remultStatic } from '../remult-static.js';
  *    allowApiCrud: true
  * })
  * export class Task {
- *    @Fields.uuid()
+ *    @Fields.id()
  *    id!: string;
  *    @Fields.string()
  *    title = '';

package/esm/src/server-action.js

@@ -1,4 +1,3 @@
-import 'reflect-metadata';
 import { buildRestDataProvider } from './buildRestDataProvider.js';
 import { ClassHelper, Remult, doTransaction, isBackend, setControllerSettings, } from './context.js';
 import { SqlDatabase } from './data-providers/sql-database.js';
@@ -137,9 +136,11 @@ export function BackendMethod(options) {
         let result = originalMethod;
         checkTarget(target);
         function getTypes() {
-            var types = typeof Reflect.getMetadata == 'function'
-                ? Reflect.getMetadata('design:paramtypes', target, key)
-                : [];
+            // removing import 'reflect-metadata' from server-action.ts, so we return an empty array
+            var types = [];
+            // typeof Reflect.getMetadata == 'function'
+            //   ? Reflect.getMetadata('design:paramtypes', target, key)
+            //   : []
             if (options.paramTypes)
                 types =
                     typeof options.paramTypes === 'function'

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "remult",
-    "version": "3.0.6",
+    "version": "3.1.0-next.1",
     "description": "A CRUD framework for full-stack TypeScript",
     "homepage": "https://remult.dev",
     "repository": {
@@ -17,12 +17,13 @@
         {
             "name": "Yoni Rapoport",
             "email": "yoni.rapoport@gmail.com"
+        },
+        {
+            "name": "Jean-Yves COUËT",
+            "email": "jycouet@gmail.com"
         }
     ],
     "dependencies": {
-        "@paralleldrive/cuid2": "^2.2.1",
-        "uuid": "^8.3.2",
-        "reflect-metadata": "^0.1.13",
         "tslib": "^2.3.1"
     },
     "exports": {

package/remult-express.js

@@ -14,15 +14,24 @@ function remultApi(options) {
     if (options.bodySizeLimit === undefined) {
         options.bodySizeLimit = '10mb';
     }
+    var expressVersion = typeof app.del === 'function' ? 4 : 5;
     if ((options === null || options === void 0 ? void 0 : options.bodyParser) !== false) {
         app.use(express.json({ limit: options.bodySizeLimit }));
         app.use(express.urlencoded({ extended: true, limit: options.bodySizeLimit }));
     }
     var server = (0, index_js_1.createRemultServer)(options, {
-        buildGenericRequestInfo: function (req) { return ({
-            internal: tslib_1.__assign(tslib_1.__assign({}, req), { on: req.on }),
-            public: { headers: new Headers(req.headers) },
-        }); },
+        buildGenericRequestInfo: function (req) {
+            var internal = tslib_1.__assign(tslib_1.__assign({}, req), { on: req.on });
+            if (expressVersion === 5) {
+                if (!internal.query) {
+                    internal.query = req.query;
+                }
+            }
+            return {
+                internal: internal,
+                public: { headers: new Headers(req.headers) },
+            };
+        },
         getRequestBody: function (req) { return tslib_1.__awaiter(_this, void 0, void 0, function () { return tslib_1.__generator(this, function (_a) {
             return [2 /*return*/, req.body];
         }); }); },