remult 0.25.5-exp.2 → 0.25.5-exp.21

package/esm/server/remult-admin.js

@@ -0,0 +1,92 @@
+import { CompoundIdField } from '../src/CompoundIdField.js';
+import { getRelationFieldInfo, } from '../src/remult3/relationInfoMember.js';
+import { Filter } from '../src/filter/filter-interfaces.js';
+import { getHtml } from './get-remult-admin-html.js';
+export default function remultAdminHtml(options) {
+    let optionsFromServer = { ...options };
+    //@ts-ignore
+    delete optionsFromServer.entities;
+    delete optionsFromServer.remult;
+    return getHtml().replace('<!--PLACE_HERE-->', `<script >const entities = ${JSON.stringify(buildEntityInfo(options))}
+    const optionsFromServer = ${JSON.stringify(optionsFromServer)}
+    </script>`);
+}
+export function buildEntityInfo(options) {
+    const entities = [];
+    for (const metadata of options.entities.map((e) => options.remult.repo(e).metadata)) {
+        let fields = [];
+        let relations = [];
+        let ids = {};
+        if (metadata.idMetadata.field instanceof CompoundIdField) {
+            for (const field of metadata.idMetadata.field.fields) {
+                ids[field.key] = true;
+            }
+        }
+        else
+            ids[metadata.idMetadata.field.key] = true;
+        for (const x of metadata.fields.toArray()) {
+            if (!x.includedInApi(undefined))
+                continue;
+            let relation;
+            let valFieldKey = x.key;
+            const info = getRelationFieldInfo(x);
+            if (info) {
+                const relInfo = info.getFields();
+                const relRepo = options.remult.repo(info.toEntity);
+                const where = typeof info.options.findOptions === 'object' &&
+                    info.options.findOptions.where
+                    ? Filter.entityFilterToJson(relRepo.metadata, info.options.findOptions.where)
+                    : undefined;
+                const idField = relRepo.metadata.idMetadata.field.key;
+                if (info.type === 'reference' || info.type === 'toOne') {
+                    if (info.type == 'toOne') {
+                        for (const key in relInfo.fields) {
+                            if (Object.prototype.hasOwnProperty.call(relInfo.fields, key)) {
+                                const element = relInfo.fields[key];
+                                valFieldKey = element;
+                            }
+                        }
+                    }
+                    relation = {
+                        ...relInfo,
+                        where,
+                        entityKey: relRepo.metadata.key,
+                        idField,
+                        captionField: relRepo.metadata.fields
+                            .toArray()
+                            .find((x) => x.key != idField && x.valueType == String)?.key,
+                    };
+                }
+                else if (info.type === 'toMany') {
+                    relations.push({
+                        ...relInfo,
+                        where,
+                        entityKey: relRepo.metadata.key,
+                    });
+                    continue;
+                }
+            }
+            fields.push({
+                key: x.key,
+                valFieldKey,
+                caption: x.caption,
+                relationToOne: relation,
+                type: x.valueConverter.fieldTypeInDb == 'json'
+                    ? 'json'
+                    : x.valueType === Number
+                        ? 'number'
+                        : x.valueType === Boolean
+                            ? 'boolean'
+                            : 'string',
+            });
+        }
+        entities.push({
+            key: metadata.key,
+            caption: metadata.caption,
+            ids,
+            fields,
+            relations,
+        });
+    }
+    return entities;
+}

package/esm/src/remult-static.js

@@ -19,7 +19,8 @@ let x = {
     },
     captionTransformer: undefined,
 };
-if (process.env['IGNORE_GLOBAL_REMULT_IN_TESTS'] ||
+if ((typeof process !== 'undefined' &&
+    process.env['IGNORE_GLOBAL_REMULT_IN_TESTS']) ||
     typeof globalThis[remultStaticKey] === 'undefined') {
     globalThis[remultStaticKey] = x;
 }

package/esm/src/remult3/Fields.js

@@ -191,6 +191,9 @@ export function Field(valueType, ...options) {
             if (r.maxLength) {
                 r.validate = addValidator(r.validate, Validators.maxLength(r.maxLength));
             }
+            if (r.minLength) {
+                r.validate = addValidator(r.validate, Validators.minLength(r.minLength));
+            }
             if (!r.valueType && valueType) {
                 r.valueType = valueType();
             }
@@ -201,7 +204,10 @@ export function Field(valueType, ...options) {
                 r.dbName = r.key;
             let type = r.valueType;
             if (!type) {
-                type = Reflect.getMetadata('design:type', target, key);
+                type =
+                    typeof Reflect.getMetadata == 'function'
+                        ? Reflect.getMetadata('design:type', target, key)
+                        : [];
                 r.valueType = type;
             }
             if (!r.target)

package/esm/src/remult3/RepositoryImplementation.js

@@ -82,9 +82,7 @@ export class RepositoryImplementation {
                 const rel = getRelationFieldInfo(field);
                 if (!rel)
                     throw Error(key + ' is not a relation');
-                let repo = rel.toRepo;
-                let { findOptions, returnNull, returnUndefined } = this.findOptionsBasedOnRelation(rel, field, undefined, item, repo);
-                const toRepo = new RepositoryImplementation(repo.entity, repo.remult, repo.dataProvider, repo._info, findOptions);
+                const { toRepo, returnNull, returnUndefined } = this.getFocusedRelationRepo(field, item);
                 if (rel.type === 'toMany')
                     return toRepo;
                 else
@@ -100,6 +98,13 @@ export class RepositoryImplementation {
             },
         });
     }
+    getFocusedRelationRepo(field, item) {
+        const rel = getRelationFieldInfo(field);
+        let repo = rel.toRepo;
+        let { findOptions, returnNull, returnUndefined } = this.findOptionsBasedOnRelation(rel, field, undefined, item, repo);
+        const toRepo = new RepositoryImplementation(repo.entity, repo.remult, repo.dataProvider, repo._info, findOptions);
+        return { toRepo, returnNull, returnUndefined };
+    }
     __edp;
     get edp() {
         return this.__edp
@@ -700,7 +705,6 @@ export class RepositoryImplementation {
             where: this.metadata.idMetadata.getIdFilter(id),
         }, true);
     }
-    /* @internal*/
     async translateWhereToFilter(where) {
         if (!where)
             where = {};
@@ -1773,7 +1777,7 @@ class EntityFullInfo {
             else
                 this.idMetadata.field = r;
         }
-        else {
+        if (!this.idMetadata.field) {
             if (this.fields['id'])
                 this.idMetadata.field = this.fields['id'];
             else

package/esm/src/remult3/remult3.js

@@ -1,29 +1,57 @@
 export {};
+/*y1 - workshop
+
+* Experiment with doing this with version control - so the students can follow changes
+* Prepare stackblitz
+
+
+# influencer:
+  * review react summit
+#
+
+//y1 - admin url!
 //y1 - number default storage in knex is decimal and it by default has 8,2 - meaning only 999,999 - I think it should be way bigger than that. in firefly we do at least 18 - https://discord.com/channels/975754286384418847/1195162533447876658
+//y1 - talk about the parameter issue with backend methods
 //y1 - tried to upgrade vitest, nuxt tests are failing with loading uuid - sounds familiar?
+//y1 - I think that the tests you've setup cover next app router - I added to the setup, but not sure where else
+//y1 - select data provider per entity https://discord.com/channels/975754286384418847/976006081748807690/1201415305885397003
+
+
+//p1 - Small thing, I get SvelteKitError: Not found: /vite.svg
+//p1 - understand the to many relation for the admin, based on the to one
+//p1 - relation from order details to order gave a compound id info - and it is not true - same for the relation to product
+//p1 - live query with include
+//p1 - new row when there are relations, looks funny (see product)
+//p1 - the + row in the bottom should extend to the full width
+//p1 - adjust angular tutorial starter kit for latest angular (as is in tutorial)
+
+/*y2 -
+  @Fields.string<Category>({
+    allowApiUpdate: (c) => getEntityRef(c).isNew(),
+  })
+  Description = ""*/
 //y2 - from the crm-demo(https://crm-demo.up.railway.app/deals), after editing a deal: - _updateEntityBasedOnApi
 //y2 - Backend methods are transactions, it's not intuitive and maybe should be optional / opt in
 //y2 - how to run a transaction as a user
-//p1 - enum column
-//p1 - I think there should be a way to throw a forbidden exception
-//p1 - Write some ctrl g
+//p2 - enum column
+//p2 - I think there should be a way to throw a forbidden exception
 //y2 - get backend methods to work when specifying types for date, and entities as poco's
 //y2 - required
 //y2 - reconsider validators
 //y2 - message for invalid value
 //y2 - message for relation that is missing
-//p1 - more column types
+//p2 - more column types
 //p2 -   processError in remult express
 //p2 -   allow find options preprocessor for api calls, to use for authorization
-//p1 - write doc about controlling updates of rows...
+//p2 - write doc about controlling updates of rows...
 //p1 - need a way to extract the fields from the relation - for generating relation based sql
 //p1 - when doing this, work on graphql relation with fields not just field
-//p1 - add docs for apply changes
-//p1 - when subscribe is forbidden - the query still runs after the renew process
-//p1 - 'update tasks set  where id = $1
+//p2 - add docs for apply changes
+//p2 - when subscribe is forbidden - the query still runs after the renew process
+//p2 - 'update tasks set  where id = $1
 //y2 - consider multi tenancies
 //y2 - allow api read to also support instance and filter. - problem with promise
-//p1 - doc this:
+//p2 - doc this:
 /**
  * //p2 - doc this
 remult.apiClient.httpClient = (
@@ -46,12 +74,12 @@ remult.apiClient.url='localhost:3007/api
 */
 //p1 - remult-admin doesn't handle primary key that has compound column
 //p1 - remult-admin didn't show a update for a table with a uniqua that is numeric
-//p1 - crm demo graphql error
-//p1 - fix multiple instances of remult: the defaultRemult and async local hook - and columnsOfType - all can be tests with a vite project loading `remult-admin`
 //p1 -check if checouknt doesn't respect allow read (I think)
+//p1 - when a tasks table exists in a different schema - we get many errors
 //p1 - allow api update only for new rows
 //p1 - getFields didn't work for kobi in the home component
-//p1 - https://codesandbox.io/p/devbox/demo-sql-expression-wqvj4g
+//p1 - add to docs  https://codesandbox.io/p/devbox/demo-sql-expression-wqvj4g
+//y1 - talk about export api is not possible in +server - how did we face that in others, and how do we doc it
 //p2 - document validators
 //p2 - and validators to reference
 //y2 - discuss a default date formatter
@@ -81,3 +109,10 @@ remult.apiClient.url='localhost:3007/api
 //y2 - should enforce integer - currently we probably round / truncate it
 //p1 - adjust react tutorial to esm
 //p1 - write docs on with remult - and usage in init api
+/*y1 - discuss sql stuff:
+     https://discord.com/channels/975754286384418847/975754286384418852/1198997156678357043
+     https://codesandbox.io/p/devbox/demo-sql-expression-forked-f94p6m?file=%2Fsrc%2Findex.ts%3A21%2C3-21%2C12&workspaceId=c0f7eccf-c151-423b-ac8e-0f0f3e1ad350
+     https://codesandbox.io/p/devbox/demo-sql-expression-forked-c2jhyc?file=%2Fsrc%2Findex.ts%3A37%2C50&workspaceId=7e9d0505-ea79-46f1-8973-50cadde4fa96
+
+
+*/

package/esm/src/server-action.js

@@ -92,7 +92,7 @@ export class myServerAction extends Action {
         await doTransaction(remult, async () => {
             if (!remult.isAllowedForInstance(undefined, this.options.allowed))
                 throw new ForbiddenError();
-            info.args = await prepareReceivedArgs(this.types, info.args, remult, ds, res);
+            info.args = await prepareReceivedArgs(this.types(), info.args, remult, ds, res);
             try {
                 result.data = await this.originalMethod(info.args);
             }
@@ -119,14 +119,22 @@ export function BackendMethod(options) {
         const originalMethod = descriptor ? descriptor.value : target;
         let result = originalMethod;
         checkTarget(target);
-        if (target.prototype !== undefined) {
-            var types = Reflect.getMetadata('design:paramtypes', target, key);
+        function getTypes() {
+            var types = typeof Reflect.getMetadata == 'function'
+                ? Reflect.getMetadata('design:paramtypes', target, key)
+                : [];
             if (options.paramTypes)
-                types = options.paramTypes;
+                types =
+                    typeof options.paramTypes === 'function'
+                        ? options.paramTypes()
+                        : options.paramTypes;
+            return types;
+        }
+        if (target.prototype !== undefined) {
             // if types are undefined - you've forgot to set: "emitDecoratorMetadata":true
-            let serverAction = new myServerAction((options?.apiPrefix ? options.apiPrefix + '/' : '') + key, types, options, (args) => originalMethod.apply(undefined, args));
+            let serverAction = new myServerAction((options?.apiPrefix ? options.apiPrefix + '/' : '') + key, () => getTypes(), options, (args) => originalMethod.apply(undefined, args));
             serverAction.doWork = async (args, self, url, http) => {
-                args = prepareArgsToSend(types, args);
+                args = prepareArgsToSend(getTypes(), args);
                 if (options.blockUser === false) {
                     return await remultStatic.actionInfo.runActionWithoutBlockingUI(async () => (await serverAction.run({ args }, url, http)).data);
                 }
@@ -149,9 +157,6 @@ export function BackendMethod(options) {
             else
                 return result;
         }
-        var types = Reflect.getMetadata('design:paramtypes', target, key);
-        if (options.paramTypes)
-            types = options.paramTypes;
         let x = remultStatic.classHelpers.get(target.constructor);
         if (!x) {
             x = new ClassHelper();
@@ -175,7 +180,7 @@ export function BackendMethod(options) {
                             let remult = req;
                             let r;
                             await doTransaction(remult, async () => {
-                                d.args = await prepareReceivedArgs(types, d.args, remult, remult.dataProvider, res);
+                                d.args = await prepareReceivedArgs(getTypes(), d.args, remult, remult.dataProvider, res);
                                 if (remultStatic.allEntities.includes(constructor)) {
                                     let repo = remult.repo(constructor);
                                     let y;
@@ -246,7 +251,7 @@ export function BackendMethod(options) {
                 }
             },
             doWork: async function (args, self, baseUrl, http) {
-                args = prepareArgsToSend(types, args);
+                args = prepareArgsToSend(getTypes(), args);
                 if (remultStatic.allEntities.includes(target.constructor)) {
                     let defs = getEntityRef(self);
                     await defs.__validateEntity();

package/esm/src/sort.js

@@ -63,8 +63,8 @@ export class Sort {
                     };
                     if (field) {
                         const rel = getRelationFieldInfo(field);
-                        const op = field.options; //p1 - fix
                         if (rel?.type === 'toOne') {
+                            const op = rel.options;
                             if (typeof op.field === 'string') {
                                 addSegment(entityDefs.fields.find(op.field));
                             }