remult 0.25.6-exp.4 → 0.25.6-exp.6

package/esm/postgres/postgres-data-provider.js

@@ -29,6 +29,8 @@ export class PostgresDataProvider {
             this.wrapIdentifier = options.wrapIdentifier;
         if (!options?.wrapIdentifier && options?.caseInsensitiveIdentifiers)
             this.wrapIdentifier = (name) => name;
+        if (options.orderByNullsFirst)
+            this.orderByNullsFirst = options.orderByNullsFirst;
         if (options?.schema) {
             this.pool = new PostgresSchemaWrapper(pool, options.schema);
         }
@@ -42,6 +44,7 @@ export class PostgresDataProvider {
         var sb = new PostgresSchemaBuilder(db, this.options?.schema);
         await sb.ensureSchema(entities);
     }
+    orderByNullsFirst;
     async transaction(action) {
         let client = await this.pool.connect();
         try {
@@ -57,6 +60,7 @@ export class PostgresDataProvider {
                 //@ts-ignore
                 pool: client,
                 wrapIdentifier: this.wrapIdentifier,
+                orderByNullsFirst: this.orderByNullsFirst,
             });
             await client.query('COMMIT');
         }
@@ -129,6 +133,7 @@ export async function createPostgresDataProvider(options) {
         wrapIdentifier: options.wrapIdentifier,
         caseInsensitiveIdentifiers: options.caseInsensitiveIdentifiers,
         schema: options.schema,
+        orderByNullsFirst: options.orderByNullsFirst,
     }));
     let remult = new Remult();
     remult.dataProvider = db;

package/esm/remult-hono.js

@@ -0,0 +1,104 @@
+import { Hono } from 'hono';
+import { streamSSE } from 'hono/streaming';
+import { createRemultServer, } from './server/index.js';
+export function remultHono(options) {
+    let app = new Hono();
+    const api = createRemultServer(options, {
+        buildGenericRequestInfo: (c) => {
+            return {
+                method: c.req.method,
+                params: c.req.param(),
+                query: new Proxy(c.req, {
+                    get: (target, prop) => {
+                        const r = c.req.queries(prop);
+                        if (r?.length == 1)
+                            return r[0];
+                        return r;
+                    },
+                }),
+                url: c.req.url,
+                on: (e, do1) => {
+                    c['_tempOnClose'](() => do1());
+                    //   c.req.on('close', do1)
+                },
+            };
+        },
+        getRequestBody: async (c) => {
+            return c.req.json();
+        },
+    });
+    let honoRouter = {
+        route(path) {
+            if (path.endsWith('*'))
+                path = path.substring(0, path.length - 1) + '.*';
+            let r = {
+                get(handler) {
+                    app.get(path, honoHandler(handler));
+                    return r;
+                },
+                post(handler) {
+                    app.post(path, honoHandler(handler));
+                    return r;
+                },
+                put(handler) {
+                    app.put(path, honoHandler(handler));
+                    return r;
+                },
+                delete(handler) {
+                    app.delete(path, honoHandler(handler));
+                    return r;
+                },
+            };
+            return r;
+            function honoHandler(handler) {
+                return (c) => {
+                    return new Promise((res, rej) => {
+                        try {
+                            let result;
+                            let sse;
+                            const gRes = {
+                                json: (data) => {
+                                    res(c.json(data));
+                                },
+                                status: (status) => {
+                                    result = c.status(status);
+                                    return gRes;
+                                },
+                                end: () => {
+                                    if (sse)
+                                        sse.close();
+                                    else
+                                        res(c.text(''));
+                                },
+                                send: (data) => {
+                                    res(c.html(data));
+                                },
+                                write: (data) => {
+                                    sse.write(data);
+                                },
+                                writeHead: (status, headers) => {
+                                    res(streamSSE(c, (s) => {
+                                        sse = s;
+                                        return new Promise((res) => {
+                                            c['_tempOnClose'] = (x) => sse.onAbort(() => x);
+                                        });
+                                    }));
+                                },
+                            };
+                            handler(c, gRes, () => { });
+                        }
+                        catch (err) {
+                            rej(err);
+                        }
+                    });
+                };
+            }
+        },
+    };
+    api.registerRouter(honoRouter);
+    return Object.assign(app, {
+        getRemult: (c) => api.getRemult(c),
+        openApiDoc: (options) => api.openApiDoc(options),
+        withRemult: async (c, what) => api.withRemultAsync(c, what),
+    });
+}

package/esm/src/data-providers/sql-database.js

@@ -249,6 +249,12 @@ class ActualSQLServerDataProvider {
                     select += e.$dbNameOf(c.field);
                     if (c.isDescending)
                         select += ' desc';
+                    if (this.sql._getSourceSql().orderByNullsFirst) {
+                        if (c.isDescending)
+                            select += ' nulls last';
+                        else
+                            select += ' nulls first';
+                    }
                 }
             }
             if (options.limit) {

package/esm/src/validators.js

@@ -89,12 +89,12 @@ export function createValueValidator(validate, defaultMessage) {
     }, defaultMessage);
 }
 export function createValueValidatorWithArgs(validate, defaultMessage) {
-    const result = createValidatorWithArgs((_, e, args) => {
+    const result = createValidatorWithArgsInternal((_, e, args) => {
         if (e.value === undefined || e.value === null)
             return true;
         return validate(e.value, args);
     }, (_, e, args) => (typeof defaultMessage === 'function' && defaultMessage(args)) ||
-        defaultMessage);
+        defaultMessage, true);
     return Object.assign((entity, e) => result(entity, e), {
         get defaultMessage() {
             return defaultMessage;
@@ -105,13 +105,21 @@ export function createValueValidatorWithArgs(validate, defaultMessage) {
     });
 }
 export function createValidatorWithArgs(validate, defaultMessage) {
+    return createValidatorWithArgsInternal(validate, defaultMessage);
+}
+function createValidatorWithArgsInternal(validate, defaultMessage, isValueValidator = false) {
     const result = (args, message) => async (entity, e) => {
         const valid = await validate(entity, e, args);
         if (typeof valid === 'string')
             e.error = valid;
         else if (!valid)
-            e.error =
-                message || defaultMessage
+            e.error = message
+                ? typeof message === 'function'
+                    ? isValueValidator
+                        ? message(args)
+                        : message(entity, e, args)
+                    : message
+                : defaultMessage
                     ? typeof defaultMessage === 'function'
                         ? defaultMessage(entity, e, args)
                         : defaultMessage

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "remult",
-    "version": "0.25.6-exp.4",
+    "version": "0.25.6-exp.6",
     "description": "A CRUD framework for full-stack TypeScript",
     "homepage": "https://remult.dev",
     "repository": {
@@ -61,6 +61,11 @@
             "import": "./esm/remult-hapi.js",
             "types": "./remult-hapi.d.ts"
         },
+        "./remult-hono": {
+            "require": "./remult-hono.js",
+            "import": "./esm/remult-hono.js",
+            "types": "./remult-hono.d.ts"
+        },
         "./remult-fresh": {
             "require": "./remult-fresh.js",
             "import": "./esm/remult-fresh.js",

package/postgres/postgres-data-provider.d.ts

@@ -21,9 +21,11 @@ export declare class PostgresDataProvider implements SqlImplementation {
         wrapIdentifier?: (name: string) => string;
         caseInsensitiveIdentifiers?: boolean;
         schema?: string;
+        orderByNullsFirst?: boolean;
     });
     wrapIdentifier: (name: any) => any;
     ensureSchema(entities: EntityMetadata<any>[]): Promise<void>;
+    orderByNullsFirst?: boolean;
     transaction(action: (dataProvider: SqlImplementation) => Promise<void>): Promise<void>;
 }
 export interface PostgresCommandSource {
@@ -37,6 +39,7 @@ export declare function createPostgresDataProvider(options?: {
     wrapIdentifier?: (name: string) => string;
     caseInsensitiveIdentifiers?: boolean;
     schema?: string;
+    orderByNullsFirst?: boolean;
 }): Promise<SqlDatabase>;
 export declare function preparePostgresQueueStorage(sql: SqlDatabase): Promise<import("../server/expressBridge.js").EntityQueueStorage>;
 export declare class PostgresSchemaWrapper implements PostgresPool {

package/postgres/postgres-data-provider.js

@@ -24,6 +24,8 @@ var PostgresDataProvider = /** @class */ (function () {
             this.wrapIdentifier = options.wrapIdentifier;
         if (!(options === null || options === void 0 ? void 0 : options.wrapIdentifier) && (options === null || options === void 0 ? void 0 : options.caseInsensitiveIdentifiers))
             this.wrapIdentifier = function (name) { return name; };
+        if (options.orderByNullsFirst)
+            this.orderByNullsFirst = options.orderByNullsFirst;
         if (options === null || options === void 0 ? void 0 : options.schema) {
             this.pool = new PostgresSchemaWrapper(pool, options.schema);
         }
@@ -89,6 +91,7 @@ var PostgresDataProvider = /** @class */ (function () {
                                 //@ts-ignore
                                 pool: client,
                                 wrapIdentifier: this.wrapIdentifier,
+                                orderByNullsFirst: this.orderByNullsFirst,
                             })];
                     case 4:
                         _a.sent();
@@ -185,6 +188,7 @@ function createPostgresDataProvider(options) {
                 wrapIdentifier: options.wrapIdentifier,
                 caseInsensitiveIdentifiers: options.caseInsensitiveIdentifiers,
                 schema: options.schema,
+                orderByNullsFirst: options.orderByNullsFirst,
             }));
             remult = new context_js_1.Remult();
             remult.dataProvider = db;

package/remult-hono.d.ts

@@ -0,0 +1,7 @@
+import { type Context, type Env, Hono } from 'hono';
+import type { BlankInput } from 'hono/types';
+import { type RemultServerOptions, type RemultServerCore } from './server/index.js';
+export declare function remultHono(options: RemultServerOptions<Context<Env, '', BlankInput>>): RemultHonoServer;
+export type RemultHonoServer = Hono & RemultServerCore<Context<Env, '', BlankInput>> & {
+    withRemult: <T>(c: Context<Env, '', BlankInput>, what: () => Promise<T>) => Promise<T>;
+};

package/remult-hono.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.remultHono = void 0;
+var tslib_1 = require("tslib");
+var hono_1 = require("hono");
+var streaming_1 = require("hono/streaming");
+var index_js_1 = require("./server/index.js");
+function remultHono(options) {
+    var _this = this;
+    var app = new hono_1.Hono();
+    var api = (0, index_js_1.createRemultServer)(options, {
+        buildGenericRequestInfo: function (c) {
+            return {
+                method: c.req.method,
+                params: c.req.param(),
+                query: new Proxy(c.req, {
+                    get: function (target, prop) {
+                        var r = c.req.queries(prop);
+                        if ((r === null || r === void 0 ? void 0 : r.length) == 1)
+                            return r[0];
+                        return r;
+                    },
+                }),
+                url: c.req.url,
+                on: function (e, do1) {
+                    c['_tempOnClose'](function () { return do1(); });
+                    //   c.req.on('close', do1)
+                },
+            };
+        },
+        getRequestBody: function (c) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                return [2 /*return*/, c.req.json()];
+            });
+        }); },
+    });
+    var honoRouter = {
+        route: function (path) {
+            if (path.endsWith('*'))
+                path = path.substring(0, path.length - 1) + '.*';
+            var r = {
+                get: function (handler) {
+                    app.get(path, honoHandler(handler));
+                    return r;
+                },
+                post: function (handler) {
+                    app.post(path, honoHandler(handler));
+                    return r;
+                },
+                put: function (handler) {
+                    app.put(path, honoHandler(handler));
+                    return r;
+                },
+                delete: function (handler) {
+                    app.delete(path, honoHandler(handler));
+                    return r;
+                },
+            };
+            return r;
+            function honoHandler(handler) {
+                return function (c) {
+                    return new Promise(function (res, rej) {
+                        try {
+                            var result_1;
+                            var sse_1;
+                            var gRes_1 = {
+                                json: function (data) {
+                                    res(c.json(data));
+                                },
+                                status: function (status) {
+                                    result_1 = c.status(status);
+                                    return gRes_1;
+                                },
+                                end: function () {
+                                    if (sse_1)
+                                        sse_1.close();
+                                    else
+                                        res(c.text(''));
+                                },
+                                send: function (data) {
+                                    res(c.html(data));
+                                },
+                                write: function (data) {
+                                    sse_1.write(data);
+                                },
+                                writeHead: function (status, headers) {
+                                    res((0, streaming_1.streamSSE)(c, function (s) {
+                                        sse_1 = s;
+                                        return new Promise(function (res) {
+                                            c['_tempOnClose'] = function (x) { return sse_1.onAbort(function () { return x; }); };
+                                        });
+                                    }));
+                                },
+                            };
+                            handler(c, gRes_1, function () { });
+                        }
+                        catch (err) {
+                            rej(err);
+                        }
+                    });
+                };
+            }
+        },
+    };
+    api.registerRouter(honoRouter);
+    return Object.assign(app, {
+        getRemult: function (c) { return api.getRemult(c); },
+        openApiDoc: function (options) { return api.openApiDoc(options); },
+        withRemult: function (c, what) { return tslib_1.__awaiter(_this, void 0, void 0, function () { return tslib_1.__generator(this, function (_a) {
+            return [2 /*return*/, api.withRemultAsync(c, what)];
+        }); }); },
+    });
+}
+exports.remultHono = remultHono;

package/src/data-providers/sql-database.js

@@ -386,6 +386,12 @@ var ActualSQLServerDataProvider = /** @class */ (function () {
                                     select += e.$dbNameOf(c.field);
                                     if (c.isDescending)
                                         select += ' desc';
+                                    if (this.sql._getSourceSql().orderByNullsFirst) {
+                                        if (c.isDescending)
+                                            select += ' nulls last';
+                                        else
+                                            select += ' nulls first';
+                                    }
                                 }
                             }
                             catch (e_3_1) { e_3 = { error: e_3_1 }; }

package/src/sql-command.d.ts

@@ -6,6 +6,7 @@ export interface SqlImplementation extends HasWrapIdentifier {
     entityIsUsedForTheFirstTime(entity: EntityMetadata): Promise<void>;
     ensureSchema?(entities: EntityMetadata[]): Promise<void>;
     supportsJsonColumnType?: boolean;
+    orderByNullsFirst?: boolean;
     afterMutation?: VoidFunction;
 }
 export interface HasWrapIdentifier {

package/src/validators.js

@@ -146,14 +146,14 @@ function createValueValidator(validate, defaultMessage) {
 }
 exports.createValueValidator = createValueValidator;
 function createValueValidatorWithArgs(validate, defaultMessage) {
-    var result = createValidatorWithArgs(function (_, e, args) {
+    var result = createValidatorWithArgsInternal(function (_, e, args) {
         if (e.value === undefined || e.value === null)
             return true;
         return validate(e.value, args);
     }, function (_, e, args) {
         return (typeof defaultMessage === 'function' && defaultMessage(args)) ||
             defaultMessage;
-    });
+    }, true);
     return Object.assign(function (entity, e) { return result(entity, e); }, {
         get defaultMessage() {
             return defaultMessage;
@@ -165,7 +165,12 @@ function createValueValidatorWithArgs(validate, defaultMessage) {
 }
 exports.createValueValidatorWithArgs = createValueValidatorWithArgs;
 function createValidatorWithArgs(validate, defaultMessage) {
+    return createValidatorWithArgsInternal(validate, defaultMessage);
+}
+exports.createValidatorWithArgs = createValidatorWithArgs;
+function createValidatorWithArgsInternal(validate, defaultMessage, isValueValidator) {
     var _this = this;
+    if (isValueValidator === void 0) { isValueValidator = false; }
     var result = function (args, message) {
         return function (entity, e) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
             var valid;
@@ -177,8 +182,13 @@ function createValidatorWithArgs(validate, defaultMessage) {
                         if (typeof valid === 'string')
                             e.error = valid;
                         else if (!valid)
-                            e.error =
-                                message || defaultMessage
+                            e.error = message
+                                ? typeof message === 'function'
+                                    ? isValueValidator
+                                        ? message(args)
+                                        : message(entity, e, args)
+                                    : message
+                                : defaultMessage
                                     ? typeof defaultMessage === 'function'
                                         ? defaultMessage(entity, e, args)
                                         : defaultMessage
@@ -197,4 +207,3 @@ function createValidatorWithArgs(validate, defaultMessage) {
         },
     });
 }
-exports.createValidatorWithArgs = createValidatorWithArgs;