remult 0.26.0 → 0.26.2

package/README.md

@@ -1,11 +1,11 @@
 <div align="center">
   <h1>Remult</h1>
   <p>Full-stack CRUD, simplified, with SSOT TypeScript entities</p>
-	<a href="https://circleci.com/gh/remult/remult/tree/master" rel="nofollow">
-		<img alt="CircleCI" src="https://circleci.com/gh/remult/remult/tree/master.svg?style=shield"></a>
+	<a href="https://circleci.com/gh/remult/remult/tree/main" rel="nofollow">
+		<img alt="CircleCI" src="https://circleci.com/gh/remult/remult/tree/main.svg?style=shield"></a>
 	<a href="https://codecov.io/gh/remult/remult" rel="nofollow">
-        	<img src="https://codecov.io/gh/remult/remult/branch/master/graph/badge.svg?token=LYWQRUN3D1"/></a>
-    	<a href="https://raw.githubusercontent.com/remult/remult/master/LICENSE" rel="nofollow">
+        	<img src="https://codecov.io/gh/remult/remult/branch/main/graph/badge.svg?token=LYWQRUN3D1"/></a>
+    	<a href="https://raw.githubusercontent.com/remult/remult/main/LICENSE" rel="nofollow">
 		<img alt="GitHub license" src="https://img.shields.io/badge/license-MIT-blue.svg"></a>
 	<a href="https://www.npmjs.com/package/remult" rel="nofollow">
 		<img alt="npm version" src="https://badge.fury.io/js/remult.svg"></a>
@@ -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,8 +93,8 @@ _Example:_
 // backend/index.ts
 
 import express from 'express'
-import { remultExpress } from 'remult/remult-express' // adapters for: Fastify, Next.js, Nuxt, SvelteKit, Nest, more...
-import { createPostgresDataProvider } from "remult/postgres" // supported: PostgreSQL, MySQL, SQLite, MongoDB, MSSQL and Oracle
+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'
 
 const app = express()
@@ -184,7 +184,7 @@ try {
   await repo(Product).insert({ name: '', unitPrice: -1 })
 } catch (e: any) {
   console.error(e)
-/* Detailed error object ->
+  /* Detailed error object ->
 {
   "modelState": {
     "name": "Should not be empty",
@@ -306,12 +306,13 @@ 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
 
 <a href="https://www.youtube.com/watch?v=rEoScmSVNUE" target="_blank">
   <p align="center">
-    <img src="https://github.com/remult/remult/raw/master/static/images/video-thumbnail.jpg" alt="Video thumbnail"  />
+    <img src="https://github.com/remult/remult/raw/main/static/images/video-thumbnail.jpg" alt="Video thumbnail"  />
   </p>
 </a>
 

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/server/expressBridge.js

@@ -764,7 +764,7 @@ class ExpressResponseBridgeToDataApiResponse {
         this.setStatus(204).end();
     }
     notFound() {
-        this.error({ message: 'Forbidden' }, undefined, 404);
+        this.error({ message: 'NotFound' }, undefined, 404);
     }
     async error(exception, entity, httpStatusCode) {
         let data = serializeError(exception);

package/esm/server/initAsyncHooks.js

@@ -1,5 +1,5 @@
 import { AsyncLocalStorage } from 'async_hooks';
-import { RemultAsyncLocalStorage } from '../src/context.js';
+import { RemultAsyncLocalStorage, } from '../src/context.js';
 import { remultStatic } from '../src/remult-static.js';
 let init = false;
 export function initAsyncHooks() {
@@ -11,7 +11,7 @@ export function initAsyncHooks() {
     test.run(1, async () => {
         await Promise.resolve();
         if (test.getStore() === undefined) {
-            console.log("async_hooks.AsyncLocalStorage not working, using sequential implementation (You're probably running on stackblitz, this will work on a normal nodejs environment");
+            console.log("async_hooks.AsyncLocalStorage not working, using stub implementation (You're probably running on stackblitz, this will work on a normal nodejs environment");
             remultStatic.asyncContext = new RemultAsyncLocalStorage(new SequentialRemultAsyncLocalStorageCore());
         }
     });
@@ -37,16 +37,22 @@ export class AsyncLocalStorageBridgeToRemultAsyncLocalStorageCoreImpl {
         return this.asyncLocalStorage.getStore();
     }
 }
-const ignoreInStack = ["AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore.run", "RemultAsyncLocalStorage.run", "Module.withRemult", "RemultServerImplementation.runWithRemult"];
+const ignoreInStack = [
+    'AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore.run',
+    'RemultAsyncLocalStorage.run',
+    'Module.withRemult',
+    'RemultServerImplementation.runWithRemult',
+];
 export class SequentialRemultAsyncLocalStorageCore {
     wasImplemented;
     async run(store, callback) {
-        let log = (msg) => {
-        };
+        let log = (msg) => { };
         if (false) {
             let stack = new Error().stack;
             let y = stack.split('\n');
-            while (y.length > 0 && (y[0].trim().startsWith("Error") || ignoreInStack.includes(y[0].trim().split(' ')[1]))) {
+            while (y.length > 0 &&
+                (y[0].trim().startsWith('Error') ||
+                    ignoreInStack.includes(y[0].trim().split(' ')[1]))) {
                 y.splice(0, 1);
             }
             stack = y.join('\n');
@@ -64,7 +70,7 @@ export class SequentialRemultAsyncLocalStorageCore {
             return result;
         });
         this.lastPromise = nextPromise.catch(() => {
-            log("Error on ");
+            log('Error on ');
             return undefined;
         });
         try {
@@ -80,5 +86,17 @@ export class SequentialRemultAsyncLocalStorageCore {
     lastPromise = Promise.resolve(undefined);
     currentValue;
 }
+export class StubRemultAsyncLocalStorageCore {
+    wasImplemented;
+    async run(store, callback) {
+        this.currentValue = store;
+        return await callback();
+    }
+    getStore() {
+        return this.currentValue;
+    }
+    lastPromise = Promise.resolve(undefined);
+    currentValue;
+}
 export class AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore extends AsyncLocalStorageBridgeToRemultAsyncLocalStorageCoreImpl {
 }

package/esm/src/context.js

@@ -51,7 +51,7 @@ export class Remult {
      * @param entity - the entity to use
      * @param dataProvider - an optional alternative data provider to use. Useful for writing to offline storage or an alternative data provider
      */
-    repo(entity, dataProvider) {
+    repo = (entity, dataProvider) => {
         if (dataProvider === undefined)
             dataProvider = this.dataProvider;
         let dpCache = this.repCache.get(dataProvider);
@@ -63,7 +63,7 @@ export class Remult {
             verifyFieldRelationInfo(r, this, dataProvider);
         }
         return r;
-    }
+    };
     /** Returns the current user's info */
     user;
     /** Checks if a user was authenticated */
@@ -286,5 +286,5 @@ export function withRemult(callback, options) {
     const remult = new Remult();
     if (options?.dataProvider)
         remult.dataProvider = options.dataProvider;
-    return remultStatic.asyncContext.run(remult, r => callback(r));
+    return remultStatic.asyncContext.run(remult, (r) => callback(r));
 }

package/esm/src/remult3/RepositoryImplementation.js

@@ -1373,14 +1373,16 @@ export class rowHelperImplementation extends rowHelperBase {
     }
     async delete() {
         this.__clearErrorsAndReportChanged();
-        let e = this.buildLifeCycleEvent();
+        let doDelete = true;
+        let e = this.buildLifeCycleEvent(() => (doDelete = false));
         if (!this.repository._dataProvider.isProxy) {
             if (this.info.entityInfo.deleting)
                 await this.info.entityInfo.deleting(this.instance, e);
         }
         this.__assertValidity();
         try {
-            await this.edp.delete(this.id);
+            if (doDelete)
+                await this.edp.delete(this.id);
             if (!this.repository._dataProvider.isProxy) {
                 if (this.info.entityInfo.deleted)
                     await this.info.entityInfo.deleted(this.instance, e);

package/esm/src/remult3/remult3.js

@@ -1,40 +1,49 @@
 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
-//p2 - fix dark background to also work on groups
-//y1 - JY suggestion of having generate as part of the ensure schema - not sure
-//y1 - 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?
-//y1 - consider changing the sql raw filter to return the sql, instead of setting the sql property
+//p1 - fix dark background to also work on groups
+//p1 - describe entity
+//p1 - prepare the createEntity discussion
+//p1 - fix async hooks
+//p1 - write active record article
+//p1 - maybe add decorator comment in the readme as well (I heard you've lost me in decorators) - and improve the describeClass function
+//p1 - return error on connection error
+//p1 - reconsider update many, maybe the second parameter should be in a set option - break existing
+//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}
-//p2 - article auth.js with express - played with it, requires type="module" and a few more configurations - https://github.com/noam-honig/express-auth
-//y1 - fix validators cache
+//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
-//y1 - dependency of live query tables
+//y1 - dependency of live query tables  live query refresh of view on table update
 //p1 - see why mongo tests do not run anymore
-//y1 - consider the bot that updates dependencies
-//y1 - consider replacing all errors with error classes that extend the base Error class
+//y2 - consider replacing all errors with error classes that extend the base Error class
 //y2 - should enforce integer - currently we probably round / truncate it
 //y1 - talk about filter on objects that are not loaded -  {
 //category: repo(CompoundId).create({ company: 7, index: 3, name: '' }),
 //    }
-//y1 - consider id to also support keyof (id:['company','index'])
 /*y1 - talk about modules in init express with entities/controllers,initRequest,initApi
  - support get with backend method, with url search params as the first parameter, & url as second parameter
    - support returning redirect, and plain html (For sign in scenarios)
 
  */
 //p1 - in this video I'll use remult to turn a frontend app to a fullstack app
-/*y1 - Talk JYC - JYC - add some integrity checks on delete
+/*y2 - Talk JYC - JYC - add some integrity checks on delete
   - soft delete
   - delete restrict (implicit, or user selected - and if so, how) (delete & update of id)
 
 */
 //y1 - consider sql expression gets a dbnames of it's own (that already has the "tableName" defined correctly) maybe also the filter translator
 //y1 - tried to upgrade vitest, nuxt tests are failing with loading uuid - sounds familiar?
-//y1 - I think that the tests you've setup don't cover next app router - I added to the setup, but not sure where else
 //y1 - talk about the parameter issue with backend methods
-//y1 - select data provider per entity https://discord.com/channels/975754286384418847/976006081748807690/1201415305885397003
-//y1 - live query refresh of view on table update
 //y1 - main vs master
 //y2 - livequery for findfirst (@JY)
 /*y2 -

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "remult",
-    "version": "0.26.0",
+    "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/server/expressBridge.js

@@ -1086,7 +1086,7 @@ var ExpressResponseBridgeToDataApiResponse = /** @class */ (function () {
         this.setStatus(204).end();
     };
     ExpressResponseBridgeToDataApiResponse.prototype.notFound = function () {
-        this.error({ message: 'Forbidden' }, undefined, 404);
+        this.error({ message: 'NotFound' }, undefined, 404);
     };
     ExpressResponseBridgeToDataApiResponse.prototype.error = function (exception, entity, httpStatusCode) {
         var _a;

package/server/initAsyncHooks.d.ts

@@ -13,5 +13,12 @@ export declare class SequentialRemultAsyncLocalStorageCore<T> implements RemultA
     lastPromise: Promise<T>;
     currentValue: T;
 }
+export declare class StubRemultAsyncLocalStorageCore<T> implements RemultAsyncLocalStorageCore<T> {
+    wasImplemented: 'yes';
+    run<R>(store: T, callback: () => Promise<R>): Promise<R>;
+    getStore(): T;
+    lastPromise: Promise<T>;
+    currentValue: T;
+}
 export declare class AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore<T> extends AsyncLocalStorageBridgeToRemultAsyncLocalStorageCoreImpl<T> {
 }

package/server/initAsyncHooks.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore = exports.SequentialRemultAsyncLocalStorageCore = exports.AsyncLocalStorageBridgeToRemultAsyncLocalStorageCoreImpl = exports.initAsyncHooks = void 0;
+exports.AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore = exports.StubRemultAsyncLocalStorageCore = exports.SequentialRemultAsyncLocalStorageCore = exports.AsyncLocalStorageBridgeToRemultAsyncLocalStorageCoreImpl = exports.initAsyncHooks = void 0;
 var tslib_1 = require("tslib");
 var async_hooks_1 = require("async_hooks");
 var context_js_1 = require("../src/context.js");
@@ -20,7 +20,7 @@ function initAsyncHooks() {
                 case 1:
                     _a.sent();
                     if (test.getStore() === undefined) {
-                        console.log("async_hooks.AsyncLocalStorage not working, using sequential implementation (You're probably running on stackblitz, this will work on a normal nodejs environment");
+                        console.log("async_hooks.AsyncLocalStorage not working, using stub implementation (You're probably running on stackblitz, this will work on a normal nodejs environment");
                         remult_static_js_1.remultStatic.asyncContext = new context_js_1.RemultAsyncLocalStorage(new SequentialRemultAsyncLocalStorageCore());
                     }
                     return [2 /*return*/];
@@ -65,7 +65,12 @@ var AsyncLocalStorageBridgeToRemultAsyncLocalStorageCoreImpl = /** @class */ (fu
     return AsyncLocalStorageBridgeToRemultAsyncLocalStorageCoreImpl;
 }());
 exports.AsyncLocalStorageBridgeToRemultAsyncLocalStorageCoreImpl = AsyncLocalStorageBridgeToRemultAsyncLocalStorageCoreImpl;
-var ignoreInStack = ["AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore.run", "RemultAsyncLocalStorage.run", "Module.withRemult", "RemultServerImplementation.runWithRemult"];
+var ignoreInStack = [
+    'AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore.run',
+    'RemultAsyncLocalStorage.run',
+    'Module.withRemult',
+    'RemultServerImplementation.runWithRemult',
+];
 var SequentialRemultAsyncLocalStorageCore = /** @class */ (function () {
     function SequentialRemultAsyncLocalStorageCore() {
         this.lastPromise = Promise.resolve(undefined);
@@ -77,12 +82,13 @@ var SequentialRemultAsyncLocalStorageCore = /** @class */ (function () {
             return tslib_1.__generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        log = function (msg) {
-                        };
+                        log = function (msg) { };
                         if (false) {
                             stack_1 = new Error().stack;
                             y = stack_1.split('\n');
-                            while (y.length > 0 && (y[0].trim().startsWith("Error") || ignoreInStack.includes(y[0].trim().split(' ')[1]))) {
+                            while (y.length > 0 &&
+                                (y[0].trim().startsWith('Error') ||
+                                    ignoreInStack.includes(y[0].trim().split(' ')[1]))) {
                                 y.splice(0, 1);
                             }
                             stack_1 = y.join('\n');
@@ -108,7 +114,7 @@ var SequentialRemultAsyncLocalStorageCore = /** @class */ (function () {
                             });
                         }); });
                         this.lastPromise = nextPromise.catch(function () {
-                            log("Error on ");
+                            log('Error on ');
                             return undefined;
                         });
                         _a.label = 1;
@@ -130,6 +136,28 @@ var SequentialRemultAsyncLocalStorageCore = /** @class */ (function () {
     return SequentialRemultAsyncLocalStorageCore;
 }());
 exports.SequentialRemultAsyncLocalStorageCore = SequentialRemultAsyncLocalStorageCore;
+var StubRemultAsyncLocalStorageCore = /** @class */ (function () {
+    function StubRemultAsyncLocalStorageCore() {
+        this.lastPromise = Promise.resolve(undefined);
+    }
+    StubRemultAsyncLocalStorageCore.prototype.run = function (store, callback) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.currentValue = store;
+                        return [4 /*yield*/, callback()];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    StubRemultAsyncLocalStorageCore.prototype.getStore = function () {
+        return this.currentValue;
+    };
+    return StubRemultAsyncLocalStorageCore;
+}());
+exports.StubRemultAsyncLocalStorageCore = StubRemultAsyncLocalStorageCore;
 var AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore = /** @class */ (function (_super) {
     tslib_1.__extends(AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore, _super);
     function AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore() {

package/src/context.d.ts

@@ -26,7 +26,7 @@ export declare class Remult {
      * @param entity - the entity to use
      * @param dataProvider - an optional alternative data provider to use. Useful for writing to offline storage or an alternative data provider
      */
-    repo<T>(entity: ClassType<T>, dataProvider?: DataProvider): Repository<T>;
+    repo: <T>(entity: ClassType<T>, dataProvider?: DataProvider) => Repository<T>;
     /** Returns the current user's info */
     user?: UserInfo;
     /** Checks if a user was authenticated */
@@ -102,15 +102,22 @@ export interface ApiClient {
      *
      * @example
      * // Adding bearer token authorization
-     * remult.apiClient.httpClient = (input: RequestInfo | URL, init?: RequestInit) => {
+     * remult.apiClient.httpClient = (
+     *   input: RequestInfo | URL,
+     *   init?: RequestInit
+     * ) => {
      *   return fetch(input, {
      *     ...init,
-     *     headers: {
-     *       authorization: 'Bearer ' + sessionStorage.sessionId,
-     *     },
+     *     headers: authToken
+     *       ? {
+     *           ...init?.headers,
+     *           authorization: 'Bearer ' + authToken,
+     *         }
+     *       : init?.headers,
+     *
      *     cache: 'no-store',
-     *   });
-     * };
+     *   })
+     * }
      */
     httpClient?: ExternalHttpProvider | typeof fetch;
     /**

package/src/context.js

@@ -57,6 +57,26 @@ exports.isBackend = isBackend;
 var Remult = /** @class */ (function () {
     function Remult(provider) {
         var _this = this;
+        /**Return's a `Repository` of the specific entity type
+         * @example
+         * const taskRepo = remult.repo(Task);
+         * @see [Repository](https://remult.dev/docs/ref_repository.html)
+         * @param entity - the entity to use
+         * @param dataProvider - an optional alternative data provider to use. Useful for writing to offline storage or an alternative data provider
+         */
+        this.repo = function (entity, dataProvider) {
+            if (dataProvider === undefined)
+                dataProvider = _this.dataProvider;
+            var dpCache = _this.repCache.get(dataProvider);
+            if (!dpCache)
+                _this.repCache.set(dataProvider, (dpCache = new Map()));
+            var r = dpCache.get(entity);
+            if (!r) {
+                dpCache.set(entity, (r = new RepositoryImplementation_js_1.RepositoryImplementation(entity, _this, dataProvider, (0, RepositoryImplementation_js_1.createOldEntity)(entity, _this))));
+                (0, relationInfoMember_js_1.verifyFieldRelationInfo)(r, _this, dataProvider);
+            }
+            return r;
+        };
         /** The current data provider */
         this.dataProvider = new rest_data_provider_js_1.RestDataProvider(function () { return _this.apiClient; });
         /* @internal */
@@ -97,26 +117,6 @@ var Remult = /** @class */ (function () {
                 this.apiClient.wrapMessageHandling = apiClient.wrapMessageHandling;
         }
     }
-    /**Return's a `Repository` of the specific entity type
-     * @example
-     * const taskRepo = remult.repo(Task);
-     * @see [Repository](https://remult.dev/docs/ref_repository.html)
-     * @param entity - the entity to use
-     * @param dataProvider - an optional alternative data provider to use. Useful for writing to offline storage or an alternative data provider
-     */
-    Remult.prototype.repo = function (entity, dataProvider) {
-        if (dataProvider === undefined)
-            dataProvider = this.dataProvider;
-        var dpCache = this.repCache.get(dataProvider);
-        if (!dpCache)
-            this.repCache.set(dataProvider, (dpCache = new Map()));
-        var r = dpCache.get(entity);
-        if (!r) {
-            dpCache.set(entity, (r = new RepositoryImplementation_js_1.RepositoryImplementation(entity, this, dataProvider, (0, RepositoryImplementation_js_1.createOldEntity)(entity, this))));
-            (0, relationInfoMember_js_1.verifyFieldRelationInfo)(r, this, dataProvider);
-        }
-        return r;
-    };
     /** Checks if a user was authenticated */
     Remult.prototype.authenticated = function () {
         var _a;

package/src/remult3/RepositoryImplementation.js

@@ -2316,13 +2316,14 @@ var rowHelperImplementation = /** @class */ (function (_super) {
     };
     rowHelperImplementation.prototype.delete = function () {
         return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var e, _a, _b, listener, e_36_1, err_2;
+            var doDelete, e, _a, _b, listener, e_36_1, err_2;
             var e_36, _c;
             return tslib_1.__generator(this, function (_d) {
                 switch (_d.label) {
                     case 0:
                         this.__clearErrorsAndReportChanged();
-                        e = this.buildLifeCycleEvent();
+                        doDelete = true;
+                        e = this.buildLifeCycleEvent(function () { return (doDelete = false); });
                         if (!!this.repository._dataProvider.isProxy) return [3 /*break*/, 2];
                         if (!this.info.entityInfo.deleting) return [3 /*break*/, 2];
                         return [4 /*yield*/, this.info.entityInfo.deleting(this.instance, e)];
@@ -2333,56 +2334,59 @@ var rowHelperImplementation = /** @class */ (function (_super) {
                         this.__assertValidity();
                         _d.label = 3;
                     case 3:
-                        _d.trys.push([3, 16, , 18]);
+                        _d.trys.push([3, 17, , 19]);
+                        if (!doDelete) return [3 /*break*/, 5];
                         return [4 /*yield*/, this.edp.delete(this.id)];
                     case 4:
                         _d.sent();
-                        if (!!this.repository._dataProvider.isProxy) return [3 /*break*/, 6];
-                        if (!this.info.entityInfo.deleted) return [3 /*break*/, 6];
-                        return [4 /*yield*/, this.info.entityInfo.deleted(this.instance, e)];
+                        _d.label = 5;
                     case 5:
-                        _d.sent();
-                        _d.label = 6;
+                        if (!!this.repository._dataProvider.isProxy) return [3 /*break*/, 7];
+                        if (!this.info.entityInfo.deleted) return [3 /*break*/, 7];
+                        return [4 /*yield*/, this.info.entityInfo.deleted(this.instance, e)];
                     case 6:
-                        if (!this.repository.listeners) return [3 /*break*/, 14];
+                        _d.sent();
                         _d.label = 7;
                     case 7:
-                        _d.trys.push([7, 12, 13, 14]);
-                        _a = tslib_1.__values(this.repository.listeners.filter(function (x) { return x.deleted; })), _b = _a.next();
+                        if (!this.repository.listeners) return [3 /*break*/, 15];
                         _d.label = 8;
                     case 8:
-                        if (!!_b.done) return [3 /*break*/, 11];
+                        _d.trys.push([8, 13, 14, 15]);
+                        _a = tslib_1.__values(this.repository.listeners.filter(function (x) { return x.deleted; })), _b = _a.next();
+                        _d.label = 9;
+                    case 9:
+                        if (!!_b.done) return [3 /*break*/, 12];
                         listener = _b.value;
                         return [4 /*yield*/, listener.deleted(this.instance)];
-                    case 9:
-                        _d.sent();
-                        _d.label = 10;
                     case 10:
+                        _d.sent();
+                        _d.label = 11;
+                    case 11:
                         _b = _a.next();
-                        return [3 /*break*/, 8];
-                    case 11: return [3 /*break*/, 14];
-                    case 12:
+                        return [3 /*break*/, 9];
+                    case 12: return [3 /*break*/, 15];
+                    case 13:
                         e_36_1 = _d.sent();
                         e_36 = { error: e_36_1 };
-                        return [3 /*break*/, 14];
-                    case 13:
+                        return [3 /*break*/, 15];
+                    case 14:
                         try {
                             if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
                         }
                         finally { if (e_36) throw e_36.error; }
                         return [7 /*endfinally*/];
-                    case 14: return [4 /*yield*/, this.repository._remult.liveQueryPublisher.itemChanged(this.repository.metadata.key, [{ id: this.getId(), oldId: this.getOriginalId(), deleted: true }])];
-                    case 15:
+                    case 15: return [4 /*yield*/, this.repository._remult.liveQueryPublisher.itemChanged(this.repository.metadata.key, [{ id: this.getId(), oldId: this.getOriginalId(), deleted: true }])];
+                    case 16:
                         _d.sent();
                         this._wasDeleted = true;
-                        return [3 /*break*/, 18];
-                    case 16:
+                        return [3 /*break*/, 19];
+                    case 17:
                         err_2 = _d.sent();
                         return [4 /*yield*/, this.catchSaveErrors(err_2)];
-                    case 17:
+                    case 18:
                         _d.sent();
-                        return [3 /*break*/, 18];
-                    case 18: return [2 /*return*/];
+                        return [3 /*break*/, 19];
+                    case 19: return [2 /*return*/];
                 }
             });
         });

package/src/remult3/remult3.js

@@ -1,41 +1,50 @@
 "use strict";
 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
-//p2 - fix dark background to also work on groups
-//y1 - JY suggestion of having generate as part of the ensure schema - not sure
-//y1 - 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?
-//y1 - consider changing the sql raw filter to return the sql, instead of setting the sql property
+//p1 - fix dark background to also work on groups
+//p1 - describe entity
+//p1 - prepare the createEntity discussion
+//p1 - fix async hooks
+//p1 - write active record article
+//p1 - maybe add decorator comment in the readme as well (I heard you've lost me in decorators) - and improve the describeClass function
+//p1 - return error on connection error
+//p1 - reconsider update many, maybe the second parameter should be in a set option - break existing
+//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}
-//p2 - article auth.js with express - played with it, requires type="module" and a few more configurations - https://github.com/noam-honig/express-auth
-//y1 - fix validators cache
+//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
-//y1 - dependency of live query tables
+//y1 - dependency of live query tables  live query refresh of view on table update
 //p1 - see why mongo tests do not run anymore
-//y1 - consider the bot that updates dependencies
-//y1 - consider replacing all errors with error classes that extend the base Error class
+//y2 - consider replacing all errors with error classes that extend the base Error class
 //y2 - should enforce integer - currently we probably round / truncate it
 //y1 - talk about filter on objects that are not loaded -  {
 //category: repo(CompoundId).create({ company: 7, index: 3, name: '' }),
 //    }
-//y1 - consider id to also support keyof (id:['company','index'])
 /*y1 - talk about modules in init express with entities/controllers,initRequest,initApi
  - support get with backend method, with url search params as the first parameter, & url as second parameter
    - support returning redirect, and plain html (For sign in scenarios)
 
  */
 //p1 - in this video I'll use remult to turn a frontend app to a fullstack app
-/*y1 - Talk JYC - JYC - add some integrity checks on delete
+/*y2 - Talk JYC - JYC - add some integrity checks on delete
   - soft delete
   - delete restrict (implicit, or user selected - and if so, how) (delete & update of id)
 
 */
 //y1 - consider sql expression gets a dbnames of it's own (that already has the "tableName" defined correctly) maybe also the filter translator
 //y1 - tried to upgrade vitest, nuxt tests are failing with loading uuid - sounds familiar?
-//y1 - I think that the tests you've setup don't cover next app router - I added to the setup, but not sure where else
 //y1 - talk about the parameter issue with backend methods
-//y1 - select data provider per entity https://discord.com/channels/975754286384418847/976006081748807690/1201415305885397003
-//y1 - live query refresh of view on table update
 //y1 - main vs master
 //y2 - livequery for findfirst (@JY)
 /*y2 -