remult 0.26.1 → 0.26.2

package/README.md

@@ -39,7 +39,7 @@ Remult uses **TypeScript entities** as a single source of truth for: ✅ CRUD +
 
 **Remult supports all major databases**, including: PostgreSQL, MySQL, SQLite, MongoDB, MSSQL and Oracle.
 
-**Remult is frontend and backend framework agnostic** and comes with adapters for Express, Fastify, Next.js, Nuxt, SvelteKit, Nest, Koa, Hapi and Hono.
+**Remult is frontend and backend framework agnostic** and comes with adapters for Express, Fastify, Next.js, Nuxt, SvelteKit, SolidStart, Nest, Koa, Hapi and Hono.
 
 Remult promotes a **consistent query syntax for both frontend and Backend code**:
 
@@ -93,7 +93,7 @@ _Example:_
 // backend/index.ts
 
 import express from 'express'
-import { remultExpress } from 'remult/remult-express' // adapters for: Fastify, Next.js, Nuxt, SvelteKit, Nest, more...
+import { remultExpress } from 'remult/remult-express' // adapters for: Fastify,Next.js, Nuxt, SvelteKit, SolidStart, Nest, more...
 import { createPostgresDataProvider } from 'remult/postgres' // supported: PostgreSQL, MySQL, SQLite, MongoDB, MSSQL and Oracle
 import { Product } from '../shared/product'
 
@@ -306,6 +306,7 @@ with a Node.js Express backend.
 - [Tutorial with Vue](https://remult.dev/tutorials/vue/)
 - [Tutorial with Next.js](https://remult.dev/tutorials/react-next/)
 - [Tutorial with Sveltekit](https://remult.dev/tutorials/sveltekit/)
+- [Tutorial with SolidStart](https://remult.dev/tutorials/react-next/)
 
 ## Demo
 

package/esm/remult-solid-start.js

@@ -0,0 +1,97 @@
+import { getRequestEvent } from 'solid-js/web';
+import { createRemultServer } from './server/index.js';
+export function remultSolidStart(options) {
+    let result = createRemultServer(options, {
+        buildGenericRequestInfo: (event) => ({
+            url: event.request.url,
+            method: event.request.method,
+            on: (e, do1) => {
+                if (e === 'close') {
+                    event.locals['_tempOnClose'] = do1;
+                }
+            },
+        }),
+        getRequestBody: (event) => event.request.json(),
+    });
+    const serverHandler = async () => {
+        const event = await getRequestEvent();
+        let sseResponse = undefined;
+        if (event)
+            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) {
+            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<Response>((res) => {
+    //     result.withRemult(event, undefined!, async () => {
+    //       res(await resolve(event))
+    //     })
+    //   })
+    // }
+    return Object.assign(handler, {
+        getRemult: (req) => result.getRemult(req),
+        openApiDoc: (options) => result.openApiDoc(options),
+        async withRemult(what) {
+            return result.withRemultAsync(await getRequestEvent(), what);
+        },
+        GET: serverHandler,
+        PUT: serverHandler,
+        POST: serverHandler,
+        DELETE: serverHandler,
+    });
+}

package/esm/src/remult3/remult3.js

@@ -1,6 +1,7 @@
 export {};
 //y1 - https://discord.com/channels/975754286384418847/1230386433093533698/1230386433093533698
 //y1 - fix async hooks - was it fixed?
+//p1 - prevent default in delete should not delete - and check proceed from there
 //p1 - release solid start with example project
 //p1 - add documentation for bun sqlite
 //p1 - fix dark background to also work on groups
@@ -14,10 +15,11 @@ export {};
 //p1 - consider upsert (where,set)
 //p1 - consider id to also support keyof (id:['company','index'])
 //p1 - consider including the admin in the tutorial - and maybe even in the demo when we setup the api
+//p1 -
 //y2 - JY suggestion of having generate as part of the ensure schema - not sure
 //y2 - currently for string fields we default for 255 in knex (which is their default) why not just use text (varchar max) - and only use exact length when one is provided?
 //p2 - create foreign key constraints in user code - https://codesandbox.io/p/devbox/fk-validator-tdshcs
-//p1 - admin url1 - pocketbase use /_ for the admin //{allowed?:Allowed,url?:string}
+//p1 - admin url1 - pocketbase use /_ for the admin //{allowed?:Allowed,url?:string} also checkout the admin* as it should probably be something else.
 //p1 - article auth.js with express - played with it, requires type="module" and a few more configurations - https://github.com/noam-honig/express-auth
 //y2 - fix validators cache
 //y2 - should we validate relations

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "remult",
-    "version": "0.26.1",
+    "version": "0.26.2",
     "description": "A CRUD framework for full-stack TypeScript",
     "homepage": "https://remult.dev",
     "repository": {
@@ -140,6 +140,11 @@
             "require": "./remult-nuxt.js",
             "import": "./esm/remult-nuxt.js",
             "types": "./remult-nuxt.d.ts"
+        },
+        "./remult-solid-start": {
+            "require": "./remult-solid-start.js",
+            "import": "./esm/remult-solid-start.js",
+            "types": "./remult-solid-start.d.ts"
         }
     },
     "main": "./index.js",

package/remult-solid-start.d.ts

@@ -0,0 +1,12 @@
+import { type RequestEvent } from 'solid-js/web';
+import type { RemultServerCore, RemultServerOptions } from './server/index.js';
+export declare function remultSolidStart(options: RemultServerOptions<RequestEvent>): RemultSolidStartServer;
+type RequestHandler = (event: RequestEvent) => Promise<Response>;
+export type RemultSolidStartServer = RemultServerCore<RequestEvent> & {
+    withRemult<T>(what: () => Promise<T>): Promise<T>;
+    GET: RequestHandler;
+    PUT: RequestHandler;
+    POST: RequestHandler;
+    DELETE: RequestHandler;
+};
+export {};

package/remult-solid-start.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.remultSolidStart = void 0;
+var tslib_1 = require("tslib");
+var web_1 = require("solid-js/web");
+var index_js_1 = require("./server/index.js");
+function remultSolidStart(options) {
+    var _this = this;
+    var result = (0, index_js_1.createRemultServer)(options, {
+        buildGenericRequestInfo: function (event) { return ({
+            url: event.request.url,
+            method: event.request.method,
+            on: function (e, do1) {
+                if (e === 'close') {
+                    event.locals['_tempOnClose'] = do1;
+                }
+            },
+        }); },
+        getRequestBody: function (event) { return event.request.json(); },
+    });
+    var serverHandler = function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+        var event, sseResponse, response, responseFromRemultHandler, res;
+        return tslib_1.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, (0, web_1.getRequestEvent)()];
+                case 1:
+                    event = _a.sent();
+                    sseResponse = undefined;
+                    if (event)
+                        event.locals['_tempOnClose'] = function () { };
+                    response = {
+                        end: function () { },
+                        json: function () { },
+                        send: function () { },
+                        status: function () {
+                            return response;
+                        },
+                        write: function () { },
+                        writeHead: function (status, headers) {
+                            if (status === 200 && headers) {
+                                var contentType = headers['Content-Type'];
+                                if (contentType === 'text/event-stream') {
+                                    var messages_1 = [];
+                                    response.write = function (x) { return messages_1.push(x); };
+                                    var stream = new ReadableStream({
+                                        start: function (controller) {
+                                            var e_1, _a;
+                                            try {
+                                                for (var messages_2 = tslib_1.__values(messages_1), messages_2_1 = messages_2.next(); !messages_2_1.done; messages_2_1 = messages_2.next()) {
+                                                    var message = messages_2_1.value;
+                                                    controller.enqueue(message);
+                                                }
+                                            }
+                                            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                                            finally {
+                                                try {
+                                                    if (messages_2_1 && !messages_2_1.done && (_a = messages_2.return)) _a.call(messages_2);
+                                                }
+                                                finally { if (e_1) throw e_1.error; }
+                                            }
+                                            response.write = function (data) {
+                                                controller.enqueue(data);
+                                            };
+                                        },
+                                        cancel: function () {
+                                            var _a, _b;
+                                            response.write = function () { };
+                                            (_b = (_a = event === null || event === void 0 ? void 0 : event.locals) === null || _a === void 0 ? void 0 : _a['_tempOnClose']) === null || _b === void 0 ? void 0 : _b.call(_a);
+                                        },
+                                    });
+                                    sseResponse = new Response(stream, { headers: headers });
+                                }
+                            }
+                        },
+                    };
+                    return [4 /*yield*/, result.handle(event, response)];
+                case 2:
+                    responseFromRemultHandler = _a.sent();
+                    if (sseResponse !== undefined) {
+                        return [2 /*return*/, sseResponse];
+                    }
+                    if (responseFromRemultHandler) {
+                        if (responseFromRemultHandler.html)
+                            return [2 /*return*/, new Response(responseFromRemultHandler.html, {
+                                    status: responseFromRemultHandler.statusCode,
+                                    headers: {
+                                        'Content-Type': 'text/html',
+                                    },
+                                })];
+                        res = new Response(JSON.stringify(responseFromRemultHandler.data), {
+                            status: responseFromRemultHandler.statusCode,
+                        });
+                        return [2 /*return*/, res];
+                    }
+                    return [2 /*return*/, new Response('Not Found', {
+                            status: 404,
+                        })];
+            }
+        });
+    }); };
+    var 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<Response>((res) => {
+    //     result.withRemult(event, undefined!, async () => {
+    //       res(await resolve(event))
+    //     })
+    //   })
+    // }
+    return Object.assign(handler, {
+        getRemult: function (req) { return result.getRemult(req); },
+        openApiDoc: function (options) { return result.openApiDoc(options); },
+        withRemult: function (what) {
+            return tslib_1.__awaiter(this, void 0, void 0, function () {
+                var _a, _b;
+                return tslib_1.__generator(this, function (_c) {
+                    switch (_c.label) {
+                        case 0:
+                            _b = (_a = result).withRemultAsync;
+                            return [4 /*yield*/, (0, web_1.getRequestEvent)()];
+                        case 1: return [2 /*return*/, _b.apply(_a, [_c.sent(), what])];
+                    }
+                });
+            });
+        },
+        GET: serverHandler,
+        PUT: serverHandler,
+        POST: serverHandler,
+        DELETE: serverHandler,
+    });
+}
+exports.remultSolidStart = remultSolidStart;

package/src/remult3/remult3.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 //y1 - https://discord.com/channels/975754286384418847/1230386433093533698/1230386433093533698
 //y1 - fix async hooks - was it fixed?
+//p1 - prevent default in delete should not delete - and check proceed from there
 //p1 - release solid start with example project
 //p1 - add documentation for bun sqlite
 //p1 - fix dark background to also work on groups
@@ -15,10 +16,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 //p1 - consider upsert (where,set)
 //p1 - consider id to also support keyof (id:['company','index'])
 //p1 - consider including the admin in the tutorial - and maybe even in the demo when we setup the api
+//p1 -
 //y2 - JY suggestion of having generate as part of the ensure schema - not sure
 //y2 - currently for string fields we default for 255 in knex (which is their default) why not just use text (varchar max) - and only use exact length when one is provided?
 //p2 - create foreign key constraints in user code - https://codesandbox.io/p/devbox/fk-validator-tdshcs
-//p1 - admin url1 - pocketbase use /_ for the admin //{allowed?:Allowed,url?:string}
+//p1 - admin url1 - pocketbase use /_ for the admin //{allowed?:Allowed,url?:string} also checkout the admin* as it should probably be something else.
 //p1 - article auth.js with express - played with it, requires type="module" and a few more configurations - https://github.com/noam-honig/express-auth
 //y2 - fix validators cache
 //y2 - should we validate relations