remult 0.25.5-exp.2 → 0.25.5-exp.20

package/esm/graphql.js

@@ -1,6 +1,7 @@
 import { getRelationFieldInfo } from './internals.js';
-import { Remult, remult } from './index.js';
+import { CompoundIdField, Remult, remult } from './index.js';
 import { DataApi } from './src/data-api.js';
+import { getRepositoryInternals } from './src/remult3/repository-internals.js';
 const v2ConnectionAndPagination = false;
 const andImplementation = false;
 let _removeComments = false;
@@ -151,6 +152,12 @@ export function remultGraphql(options) {
                     });
                 };
             };
+            const handleRequestWithDataApiContextBasedOnRepo = (repo, work) => {
+                return createResultPromise(async (response, setResult, arg1, req) => {
+                    const dApi = new DataApi(repo, remult);
+                    await work(dApi, response, setResult, arg1, repo.metadata);
+                });
+            };
             const handleRequestWithDataApiContext = (work) => {
                 return createResultPromise(async (response, setResult, arg1, req) => {
                     const remult = await options.getRemultFromRequest(req);
@@ -219,7 +226,8 @@ export function remultGraphql(options) {
                 await dApi.get({
                     ...response,
                     success: (y) => {
-                        currentType.query.resultProcessors.forEach((z) => z(y));
+                        const orig = { ...y };
+                        currentType.query.resultProcessors.forEach((z) => z(y, orig));
                         setResult(y);
                     },
                 }, arg1.id);
@@ -269,29 +277,7 @@ export function remultGraphql(options) {
                 });
             }
             root[key] = handleRequestWithDataApiContext(async (dApi, response, setResult, arg1, meta) => {
-                setResult({
-                    [itemsKey]: createResultPromise(async (response, setResult) => {
-                        await dApi.getArray({
-                            ...response,
-                            success: (x) => {
-                                setResult(x.map((y) => {
-                                    currentType.query.resultProcessors.forEach((z) => z(y));
-                                    return y;
-                                }));
-                            },
-                        }, {
-                            get: bridgeQueryOptionsToDataApiGet(arg1),
-                        }, translateWhereToRestBody(meta.fields, arg1));
-                    }),
-                    [totalCountKey]: createResultPromise(async (response, setResult) => {
-                        await dApi.count({
-                            ...response,
-                            success: (x) => setResult(x.count),
-                        }, {
-                            get: bridgeQueryOptionsToDataApiGet(arg1),
-                        }, translateWhereToRestBody(meta.fields, arg1));
-                    }),
-                });
+                connectionImplementation(setResult, itemsKey, createResultPromise, dApi, currentType, arg1, meta, totalCountKey);
             });
             resolversQuery[key] = (origItem, args, req, gqlInfo) => {
                 return root[key](args, req, gqlInfo);
@@ -326,7 +312,8 @@ export function remultGraphql(options) {
                     await dApi.post({
                         ...response,
                         created: (y) => {
-                            currentType.query.resultProcessors.forEach((z) => z(y));
+                            const orig = { ...y };
+                            currentType.query.resultProcessors.forEach((z) => z(y, orig));
                             setResult({
                                 [toCamelCase(getMetaType(meta))]: y,
                             });
@@ -360,7 +347,8 @@ export function remultGraphql(options) {
                     await dApi.put({
                         ...response,
                         success: (y) => {
-                            currentType.query.resultProcessors.forEach((z) => z(y));
+                            const orig = { ...y };
+                            currentType.query.resultProcessors.forEach((z) => z(y, orig));
                             setResult({
                                 [toCamelCase(getMetaType(meta))]: y,
                             });
@@ -381,9 +369,12 @@ export function remultGraphql(options) {
                 });
                 currentType.mutation.delete.payload = upsertTypes(deletePayload);
                 const deletedResultKey = `id`;
+                const type = meta.idMetadata.field instanceof CompoundIdField
+                    ? 'String'
+                    : getGraphqlBaseType(meta.idMetadata.field);
                 currentType.mutation.delete.payload.fields.push({
                     key: deletedResultKey,
-                    value: 'ID',
+                    value: `${type}`,
                 }, argErrorDetail, argClientMutationId);
                 root[deleteResolverKey] = handleMutationWithErrors(async (dApi, response, setResult, arg1, req) => {
                     await dApi.delete({
@@ -400,21 +391,7 @@ export function remultGraphql(options) {
                 const ri = getRelationFieldInfo(f);
                 if (f.options.includeInApi === false)
                     continue;
-                let type = 'String';
-                switch (f.valueType) {
-                    case Boolean:
-                        type = 'Boolean';
-                        break;
-                    case Number:
-                        {
-                            if (f.valueConverter?.fieldTypeInDb === 'integer' ||
-                                f.valueConverter?.fieldTypeInDb === 'autoincrement')
-                                type = 'Int';
-                            else
-                                type = 'Float';
-                        }
-                        break;
-                }
+                const type = getGraphqlBaseType(f);
                 currentType.query.resultProcessors.push((r) => {
                     r[nodeIdKey] = () => getMetaType(meta) + ':' + meta.idMetadata.getId(r);
                 });
@@ -425,6 +402,9 @@ export function remultGraphql(options) {
                         const refType = ri.toEntity;
                         ref = entities.find((i) => i.entityType === refType);
                     }
+                    if (!ref) {
+                        throw new Error(`Entity "${ri.toEntity.name}" that is used by the relation "${f.key}" in "${meta.entityType.name}" was not found in the 'entities' array.`);
+                    }
                     notARealField = ri.type === 'toOne' || ri.type === 'toMany';
                     const refKey = ref.key;
                     switch (ri.type) {
@@ -435,19 +415,19 @@ export function remultGraphql(options) {
                                 value: `${getMetaType(ref)}${f.allowNull ? '' : '!'}`,
                                 comment: f.caption,
                             });
-                            currentType.query.resultProcessors.push((r) => {
-                                const val = r[ri.type == 'reference' ? f.key : f.options.field]; //p1 - fix
-                                if (val === null || val === undefined)
-                                    return null;
+                            currentType.query.resultProcessors.push((r, orig) => {
                                 r[f.key] = async (args, req, gqlInfo) => {
-                                    const queryResult = await (await root[refKey]({
-                                        ...args.where,
-                                        where: { id: { eq: val } },
-                                        options: { limit: 1 },
-                                    }, req, gqlInfo)).items();
-                                    if (queryResult.length > 0)
-                                        return queryResult[0];
-                                    return null;
+                                    const remult = await options.getRemultFromRequest(req);
+                                    const myRepo = remult.repo(meta.entityType);
+                                    const item = myRepo.fromJson(orig);
+                                    let { toRepo, returnNull, returnUndefined } = getRepositoryInternals(myRepo).getFocusedRelationRepo(myRepo.fields.find(f), item);
+                                    if (returnNull || returnUndefined)
+                                        return null;
+                                    const result = await handleRequestWithDataApiContextBasedOnRepo(toRepo, async (dApi, response, setResult, arg1, meta) => {
+                                        return await connectionImplementation(setResult, itemsKey, createResultPromise, dApi, upsertTypes(getMetaType(ref)), arg1, meta, totalCountKey);
+                                    })({ ...args, options: { limit: 1 } }, req);
+                                    const resultItems = await result.items();
+                                    return resultItems[0];
                                 };
                             });
                             break;
@@ -460,16 +440,15 @@ export function remultGraphql(options) {
                                 order: 10,
                                 comment: `List all \`${getMetaType(meta)}\` of \`${refKey}\``,
                             });
-                            currentType.query.resultProcessors.push((r) => {
-                                const val = r.id;
+                            currentType.query.resultProcessors.push((r, y) => {
                                 r[f.key] = async (args, req, gqlInfo) => {
-                                    return await root[ref.key]({
-                                        where: {
-                                            ...args.where,
-                                            [f.options.field /*//p1 to fix*/]: { eq: val },
-                                        },
-                                        options: { ...args.limit, ...args.page, ...args.orderBy },
-                                    }, req, gqlInfo);
+                                    const remult = await options.getRemultFromRequest(req);
+                                    const myRepo = remult.repo(meta.entityType);
+                                    const item = myRepo.fromJson(y);
+                                    let relRepo = myRepo.relations(item)[f.key];
+                                    return handleRequestWithDataApiContextBasedOnRepo(relRepo, async (dApi, response, setResult, arg1, meta) => {
+                                        return await connectionImplementation(setResult, itemsKey, createResultPromise, dApi, upsertTypes(getMetaType(ref)), arg1, meta, totalCountKey);
+                                    })(args, req);
                                 };
                             });
                     }
@@ -678,6 +657,32 @@ export function remultGraphql(options) {
             .join(`\n\n`)}
 `,
     };
+    function connectionImplementation(setResult, itemsKey, createResultPromise, dApi, currentType, arg1, meta, totalCountKey) {
+        setResult({
+            [itemsKey]: createResultPromise(async (response, setResult) => {
+                await dApi.getArray({
+                    ...response,
+                    success: (x) => {
+                        setResult(x.map((y) => {
+                            const orig = { ...y };
+                            currentType.query.resultProcessors.forEach((z) => z(y, orig));
+                            return y;
+                        }));
+                    },
+                }, {
+                    get: bridgeQueryOptionsToDataApiGet(arg1),
+                }, translateWhereToRestBody(meta.fields, arg1));
+            }),
+            [totalCountKey]: createResultPromise(async (response, setResult) => {
+                await dApi.count({
+                    ...response,
+                    success: (x) => setResult(x.count),
+                }, {
+                    get: bridgeQueryOptionsToDataApiGet(arg1),
+                }, translateWhereToRestBody(meta.fields, arg1));
+            }),
+        });
+    }
 }
 function getQueryArgsConnection(key) {
     const queryArgsConnection = [
@@ -812,6 +817,24 @@ function fieldFormat(field) {
     }
     return `${strComment}  ${key_value}`;
 }
+function getGraphqlBaseType(field) {
+    let type = 'String';
+    switch (field.valueType) {
+        case Boolean:
+            type = 'Boolean';
+            break;
+        case Number:
+            {
+                if (field.valueConverter?.fieldTypeInDb === 'integer' ||
+                    field.valueConverter?.fieldTypeInDb === 'autoincrement')
+                    type = 'Int';
+                else
+                    type = 'Float';
+            }
+            break;
+    }
+    return type;
+}
 function getMetaType(entityMeta) {
     return entityMeta.entityType.name;
 }

package/esm/package.json

@@ -1,3 +1,3 @@
 {
-    "type": "module"
+  "type": "module"
 }

package/esm/remult-fastify.js

@@ -10,6 +10,9 @@ export function remultFastify(options) {
                 end() {
                     res.send();
                 },
+                send(html) {
+                    res.type('text/html').send(html);
+                },
                 json(data) {
                     res.send(data);
                 },

package/esm/remult-hapi.js

@@ -29,6 +29,9 @@ export function remultHapi(options) {
                             end() {
                                 res(h.response().code(status));
                             },
+                            send(html) {
+                                res(h.response(html).code(status));
+                            },
                             json(data) {
                                 res(h.response(data).code(status));
                             },

package/esm/remult-knex/index.js

@@ -20,7 +20,7 @@ export class KnexDataProvider {
         return r.knex;
     }
     getEntityDataProvider(entity) {
-        if (!supportsJson(this.knex))
+        if (!supportsJsonLoadingAndSaving(this.knex))
             for (const f of entity.fields.toArray()) {
                 if (f.valueConverter.fieldTypeInDb === 'json') {
                     //@ts-ignore
@@ -31,6 +31,17 @@ export class KnexDataProvider {
                     };
                 }
             }
+        else if (this.knex.client.config.client === 'mysql2') {
+            for (const f of entity.fields.toArray()) {
+                if (f.valueConverter.fieldTypeInDb === 'json') {
+                    //@ts-ignore
+                    f.valueConverter = {
+                        ...f.valueConverter,
+                        toDb: ValueConverters.JsonString.toDb,
+                    };
+                }
+            }
+        }
         return new KnexEntityDataProvider(entity, this.knex);
     }
     async transaction(action) {
@@ -367,7 +378,7 @@ export class KnexSchemaBuilder {
                         if (isAutoIncrement(x))
                             b.increments(cols.get(x).name);
                         else {
-                            buildColumn(x, cols.get(x).name, b, supportsJson(this.knex));
+                            buildColumn(x, cols.get(x).name, b, supportsJsonDataStorage(this.knex));
                             if (x == entity.idMetadata.field)
                                 b.primary([cols.get(x).name]);
                         }
@@ -384,7 +395,7 @@ export class KnexSchemaBuilder {
         let colName = e.$dbNameOf(col);
         if (!(await this.knex.schema.hasColumn(e.$entityName, colName))) {
             await logSql(this.knex.schema.alterTable(e.$entityName, (b) => {
-                buildColumn(col, colName, b, supportsJson(this.knex));
+                buildColumn(col, colName, b, supportsJsonDataStorage(this.knex));
             }));
         }
     }
@@ -406,11 +417,17 @@ export class KnexSchemaBuilder {
         this.knex = knex;
     }
 }
-function supportsJson(knex) {
+function supportsJsonDataStorage(knex) {
+    const client = knex.client.config.client;
+    if (client?.includes('sqlite3') || client?.includes('mssql'))
+        return false;
+    return true;
+}
+function supportsJsonLoadingAndSaving(knex) {
     const client = knex.client.config.client;
     if (client?.includes('sqlite3') ||
         client?.includes('mssql') ||
-        client?.includes('mysql'))
+        client == 'mysql')
         return false;
     return true;
 }

package/esm/remult-next.js

@@ -57,6 +57,7 @@ export function remultNextApp(options) {
             const response = {
                 end: () => { },
                 json: () => { },
+                send: () => { },
                 status: () => {
                     return response;
                 },
@@ -91,6 +92,13 @@ export function remultNextApp(options) {
                 return sseResponse;
             }
             if (responseFromRemultHandler) {
+                if (responseFromRemultHandler.html)
+                    return new Response(responseFromRemultHandler.html, {
+                        status: responseFromRemultHandler.statusCode,
+                        headers: {
+                            'Content-Type': 'text/html',
+                        },
+                    });
                 return new Response(JSON.stringify(responseFromRemultHandler.data), {
                     status: responseFromRemultHandler.statusCode,
                 });

package/esm/remult-nuxt.js

@@ -17,6 +17,7 @@ export function remultNuxt(options) {
         let sse = false;
         const response = {
             end: () => { },
+            send: () => { },
             json: () => { },
             status: () => {
                 return response;
@@ -38,6 +39,8 @@ export function remultNuxt(options) {
         if (r) {
             if (r.statusCode !== 200)
                 setResponseStatus(event, r.statusCode);
+            if (r.html)
+                return r.html;
             return r.data;
         }
     };

package/esm/remult-sveltekit.js

@@ -19,6 +19,7 @@ export function remultSveltekit(options) {
             const response = {
                 end: () => { },
                 json: () => { },
+                send: () => { },
                 status: () => {
                     return response;
                 },
@@ -53,8 +54,16 @@ export function remultSveltekit(options) {
                 return sseResponse;
             }
             if (responseFromRemultHandler) {
+                if (responseFromRemultHandler.html)
+                    return new Response(responseFromRemultHandler.html, {
+                        status: responseFromRemultHandler.statusCode,
+                        headers: {
+                            'Content-Type': 'text/html',
+                        },
+                    });
                 return new Response(JSON.stringify(responseFromRemultHandler.data), {
                     status: responseFromRemultHandler.statusCode,
+                    //  headers: (await resolve(event)).headers,
                 });
             }
         }

package/esm/server/expressBridge.js

@@ -12,6 +12,7 @@ import { Action, classBackendMethodsArray } from '../src/server-action.js';
 import { serverActionField } from '../src/server-action-info.js';
 import { initDataProvider } from './initDataProvider.js';
 import { remultStatic } from '../src/remult-static.js';
+import remultAdminHtml from './remult-admin.js';
 export function createRemultServerCore(options, serverCoreOptions) {
     if (!options) {
         options = {};
@@ -194,6 +195,15 @@ export class RemultServerImplementation {
                     },
                     doWork: undefined,
                 }, r);
+            if (this.options.admin) {
+                r.route(this.options.rootPath + '/admin*').get(this.process(async (remult, req, res, orig, origResponse) => {
+                    origResponse.send(remultAdminHtml({
+                        remult: remult,
+                        entities: this.options.entities,
+                        baseUrl: this.options.rootPath + '/admin',
+                    }));
+                }));
+            }
             if (this.options.subscriptionServer instanceof SseSubscriptionServer) {
                 const streamPath = this.options.rootPath + '/' + streamUrl;
                 r.route(streamPath).get(this.process(async (remult, req, res, origReq, origRes) => {
@@ -814,6 +824,7 @@ export class RouteImplementation {
         this.coreOptions = coreOptions;
     }
     map = new Map();
+    starRoutes = [];
     route(path) {
         //consider using:
         //* https://raw.githubusercontent.com/cmorten/opine/main/src/utils/pathToRegex.ts
@@ -821,6 +832,8 @@ export class RouteImplementation {
         let r = path.toLowerCase();
         let m = new Map();
         this.map.set(r, m);
+        if (path.endsWith('*'))
+            this.starRoutes.push({ route: r.substring(0, r.length - 1), handler: m });
         const route = {
             get: (h) => {
                 m.set('get', h);
@@ -864,6 +877,11 @@ export class RouteImplementation {
                         gRes.json(data);
                     res({ statusCode: this.statusCode, data });
                 }
+                send(html) {
+                    if (gRes !== undefined)
+                        gRes.send(html);
+                    res({ statusCode: this.statusCode, html });
+                }
                 status(statusCode) {
                     if (gRes !== undefined)
                         gRes.status(statusCode);
@@ -913,6 +931,13 @@ export class RouteImplementation {
         }
         let lowerPath = path.toLowerCase();
         let m = this.map.get(lowerPath);
+        if (!m)
+            for (const route of this.starRoutes) {
+                if (lowerPath.startsWith(route.route)) {
+                    m = route.handler;
+                    break;
+                }
+            }
         if (m) {
             let h = m.get(req.method.toLowerCase());
             if (h) {