remult 0.25.5-exp.8 → 0.25.5

package/esm/graphql.js

@@ -1,5 +1,5 @@
 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;
@@ -369,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({
@@ -388,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);
                 });
@@ -828,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/index.js

@@ -1,3 +1,4 @@
+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 { Entity } from './src/remult3/entity.js';
 export { getEntityRef } from './src/remult3/getEntityRef.js';

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

@@ -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) {
@@ -416,8 +427,7 @@ function supportsJsonLoadingAndSaving(knex) {
     const client = knex.client.config.client;
     if (client?.includes('sqlite3') ||
         client?.includes('mssql') ||
-        client?.includes('mysql2') ||
-        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

@@ -12,51 +12,68 @@ export function remultSveltekit(options) {
         }),
         getRequestBody: (event) => event.request.json(),
     });
-    const handler = async ({ event, resolve }) => {
-        if (event.url.pathname.startsWith(options.rootPath)) {
-            let sseResponse = undefined;
-            event.locals['_tempOnClose'] = () => { };
-            const response = {
-                end: () => { },
-                json: () => { },
-                status: () => {
-                    return response;
-                },
-                write: () => { },
-                writeHead: (status, headers) => {
-                    if (status === 200 && headers) {
-                        const contentType = headers['Content-Type'];
-                        if (contentType === 'text/event-stream') {
-                            const messages = [];
-                            response.write = (x) => messages.push(x);
-                            const stream = new ReadableStream({
-                                start: (controller) => {
-                                    for (const message of messages) {
-                                        controller.enqueue(message);
-                                    }
-                                    response.write = (data) => {
-                                        controller.enqueue(data);
-                                    };
-                                },
-                                cancel: () => {
-                                    response.write = () => { };
-                                    event.locals['_tempOnClose']();
-                                },
-                            });
-                            sseResponse = new Response(stream, { headers });
-                        }
+    const serverHandler = async (event) => {
+        let sseResponse = undefined;
+        event.locals['_tempOnClose'] = () => { };
+        const response = {
+            end: () => { },
+            json: () => { },
+            send: () => { },
+            status: () => {
+                return response;
+            },
+            write: () => { },
+            writeHead: (status, headers) => {
+                if (status === 200 && headers) {
+                    const contentType = headers['Content-Type'];
+                    if (contentType === 'text/event-stream') {
+                        const messages = [];
+                        response.write = (x) => messages.push(x);
+                        const stream = new ReadableStream({
+                            start: (controller) => {
+                                for (const message of messages) {
+                                    controller.enqueue(message);
+                                }
+                                response.write = (data) => {
+                                    controller.enqueue(data);
+                                };
+                            },
+                            cancel: () => {
+                                response.write = () => { };
+                                event.locals['_tempOnClose']();
+                            },
+                        });
+                        sseResponse = new Response(stream, { headers });
                     }
-                },
-            };
-            const responseFromRemultHandler = await result.handle(event, response);
-            if (sseResponse !== undefined) {
-                return sseResponse;
-            }
-            if (responseFromRemultHandler) {
-                return new Response(JSON.stringify(responseFromRemultHandler.data), {
+                }
+            },
+        };
+        const responseFromRemultHandler = await result.handle(event, response);
+        if (sseResponse !== undefined) {
+            return sseResponse;
+        }
+        if (responseFromRemultHandler) {
+            if (responseFromRemultHandler.html)
+                return new Response(responseFromRemultHandler.html, {
                     status: responseFromRemultHandler.statusCode,
+                    headers: {
+                        'Content-Type': 'text/html',
+                    },
                 });
-            }
+            const res = new Response(JSON.stringify(responseFromRemultHandler.data), {
+                status: responseFromRemultHandler.statusCode,
+            });
+            return res;
+        }
+        return new Response('Not Found', {
+            status: 404,
+        });
+    };
+    const handler = async ({ event, resolve }) => {
+        if (event.url.pathname.startsWith(options.rootPath)) {
+            const result = await serverHandler(event);
+            if (result != null && result?.status != 404)
+                return result;
         }
         return new Promise((res) => {
             result.withRemult(event, undefined, async () => {
@@ -70,5 +87,9 @@ export function remultSveltekit(options) {
         withRemult(request, what) {
             return result.withRemultAsync(request, what);
         },
+        GET: serverHandler,
+        PUT: serverHandler,
+        POST: serverHandler,
+        DELETE: serverHandler,
     });
 }

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,18 @@ export class RemultServerImplementation {
                     },
                     doWork: undefined,
                 }, r);
+            if (this.options.admin !== undefined && this.options.admin !== false) {
+                r.route(this.options.rootPath + '/admin*').get(this.process(async (remult, req, res, orig, origResponse) => {
+                    if (remult.isAllowed(this.options.admin))
+                        origResponse.send(remultAdminHtml({
+                            remult: remult,
+                            entities: this.options.entities,
+                            baseUrl: this.options.rootPath + '/admin',
+                        }));
+                    else
+                        res.notFound();
+                }));
+            }
             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 +827,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 +835,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 +880,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 +934,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) {