remult 0.26.23 → 0.27.1-next.0

package/SseSubscriptionServer.d.ts

@@ -1,10 +1,9 @@
-/// <reference types="node" />
 import type { GenericResponse } from './server/index.js';
 import type { Remult } from './src/context.js';
 import type { SubscriptionServer } from './src/live-query/SubscriptionServer.js';
 export declare class SseSubscriptionServer implements SubscriptionServer {
     private canUserConnectToChannel?;
-    constructor(canUserConnectToChannel?: (channel: string, remult: Remult) => boolean);
+    constructor(canUserConnectToChannel?: ((channel: string, remult: Remult) => boolean) | undefined);
     publishMessage<T>(channel: string, message: any): Promise<void>;
 }
 export interface ResponseRequiredForSSE {
@@ -15,11 +14,11 @@ export interface ResponseRequiredForSSE {
 export declare class clientConnection {
     response: GenericResponse & ResponseRequiredForSSE;
     channels: Record<string, boolean>;
-    timeOutRef: NodeJS.Timeout;
+    timeOutRef?: NodeJS.Timeout;
     close(): void;
     closed: boolean;
     write(eventData: string, eventType?: string): void;
-    connectionId: any;
+    connectionId: string;
     constructor(response: GenericResponse & ResponseRequiredForSSE);
     sendLiveMessage(): void;
 }

package/assign.js

@@ -1,9 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.assign = void 0;
+exports.assign = assign;
 function assign(item, valuesToSet) {
     if (valuesToSet)
         Object.assign(item, valuesToSet);
     return item;
 }
-exports.assign = assign;

package/esm/graphql.js

@@ -976,7 +976,7 @@ export function translateWhereToRestBody(fields, { where }) {
         }
     }
     if (where.OR) {
-        result.OR = where.OR.map((where) => translateWhereToRestBody(fields, { where }).where);
+        result.OR = where.OR.map((where) => translateWhereToRestBody(fields, { where })?.where);
     }
     return { where: result };
 }

package/esm/remult-hono.js

@@ -18,6 +18,7 @@ export function remultHono(options) {
                 }),
                 url: c.req.url,
                 on: (e, do1) => {
+                    ;
                     c['_tempOnClose'](() => do1());
                     //   c.req.on('close', do1)
                 },
@@ -78,7 +79,8 @@ export function remultHono(options) {
                                     res(streamSSE(c, (s) => {
                                         sse = s;
                                         return new Promise((res) => {
-                                            c['_tempOnClose'] = (x) => sse.onAbort(() => x);
+                                            ;
+                                            c['_tempOnClose'] = (x) => sse.onAbort(() => x());
                                         });
                                     }));
                                 },

package/esm/remult-knex/index.js

@@ -91,8 +91,10 @@ export class KnexDataProvider {
         };
     }
     static async filterToRaw(entity, condition, wrapIdentifier) {
+        if (!wrapIdentifier)
+            wrapIdentifier = (x) => x;
         const repo = getRepository(entity);
-        var b = new FilterConsumerBridgeToKnexRequest(await dbNamesOfWithForceSqlExpression(repo.metadata, (x) => x), wrapIdentifier);
+        var b = new FilterConsumerBridgeToKnexRequest(await dbNamesOfWithForceSqlExpression(repo.metadata, wrapIdentifier), wrapIdentifier ?? wrapIdentifier);
         b._addWhere = false;
         await (await getRepositoryInternals(repo)._translateWhereToFilter(condition)).__applyToConsumer(b);
         let r = await b.resolveWhere();

package/esm/remult-sqlite3.js

@@ -20,7 +20,10 @@ class Sqlite3Command {
                     if (err)
                         error(err);
                     else
-                        resolve(new Sqlite3SqlResult([this.lastID]));
+                        resolve(new Sqlite3SqlResult([
+                            //@ts-expect-error last id comes from sql lite as a lastId member of the function this
+                            this.lastID,
+                        ]));
                 });
             }
             else

package/esm/remult-sveltekit.js

@@ -6,6 +6,7 @@ export function remultSveltekit(options) {
             method: event.request.method,
             on: (e, do1) => {
                 if (e === 'close') {
+                    ;
                     event.locals['_tempOnClose'] = do1;
                 }
             },

package/esm/server/index.js

@@ -1,12 +1,13 @@
-import { createRemultServerCore } from './remult-api-server.js';
+import { createRemultServerCore, } from './remult-api-server.js';
 import { initAsyncHooks } from './initAsyncHooks.js';
+import { cast } from '../src/isOfType.js';
 export { SseSubscriptionServer } from '../SseSubscriptionServer.js';
 export { DataProviderLiveQueryStorage } from '../live-query/data-provider-live-query-storage.js';
 export { JsonEntityFileStorage, JsonFileDataProvider, } from './JsonEntityFileStorage.js';
 export function createRemultServer(options, serverCoreOptions) {
     initAsyncHooks();
     return createRemultServerCore(options, serverCoreOptions || {
-        buildGenericRequestInfo: (req) => req,
+        buildGenericRequestInfo: (req) => cast(req, 'method'),
         getRequestBody: async (req) => req.body,
     });
 }

package/esm/server/initAsyncHooks.js

@@ -18,7 +18,7 @@ export function initAsyncHooks() {
 }
 export class AsyncLocalStorageBridgeToRemultAsyncLocalStorageCoreImpl {
     asyncLocalStorage = new AsyncLocalStorage();
-    wasImplemented;
+    wasImplemented = 'yes';
     run(store, callback) {
         let r;
         this.asyncLocalStorage.run(store, () => {
@@ -44,7 +44,7 @@ const ignoreInStack = [
     'RemultServerImplementation.runWithRemult',
 ];
 export class SequentialRemultAsyncLocalStorageCore {
-    wasImplemented;
+    wasImplemented = 'yes';
     async run(store, callback) {
         let log = (msg) => { };
         if (false) {
@@ -87,7 +87,7 @@ export class SequentialRemultAsyncLocalStorageCore {
     currentValue;
 }
 export class StubRemultAsyncLocalStorageCore {
-    wasImplemented;
+    wasImplemented = 'yes';
     async run(store, callback) {
         this.currentValue = store;
         return await callback();

package/esm/server/remult-admin.js

@@ -3,10 +3,7 @@ import { Filter } from '../src/filter/filter-interfaces.js';
 import { getHtml } from './get-remult-admin-html.js';
 import { getValueList } from '../src/remult3/RepositoryImplementation.js';
 export default function remultAdminHtml(options) {
-    let optionsFromServer = { ...options };
-    //@ts-ignore
-    delete optionsFromServer.entities;
-    delete optionsFromServer.remult;
+    let { remult, entities, ...optionsFromServer } = { ...options };
     return getHtml().replace('<!--PLACE_HERE-->', `<script >const entities = ${JSON.stringify(buildEntityInfo(options))}
     const optionsFromServer = ${JSON.stringify(optionsFromServer)}
     </script>`);

package/esm/server/remult-api-server.js

@@ -15,40 +15,38 @@ import remultAdminHtml from './remult-admin.js';
 import { isOfType } from '../src/isOfType.js';
 import { initDataProviderOrJson } from './initDataProviderOrJson.js';
 export function createRemultServerCore(options, serverCoreOptions) {
-    if (!options) {
-        options = {};
+    const safeOptions = options ?? {};
+    if (!safeOptions.subscriptionServer) {
+        safeOptions.subscriptionServer = new SseSubscriptionServer();
     }
-    if (!options.subscriptionServer) {
-        options.subscriptionServer = new SseSubscriptionServer();
-    }
-    if (options.logApiEndPoints === undefined)
-        options.logApiEndPoints = true;
+    if (safeOptions.logApiEndPoints === undefined)
+        safeOptions.logApiEndPoints = true;
     remultStatic.actionInfo.runningOnServer = true;
-    if (options.defaultGetLimit) {
-        DataApi.defaultGetLimit = options.defaultGetLimit;
+    if (safeOptions.defaultGetLimit) {
+        DataApi.defaultGetLimit = safeOptions.defaultGetLimit;
     }
-    if (!options.queueStorage) {
-        options.queueStorage = new InMemoryQueueStorage();
+    if (!safeOptions.queueStorage) {
+        safeOptions.queueStorage = new InMemoryQueueStorage();
     }
-    let dataProvider = initDataProviderOrJson(options.dataProvider);
+    let dataProvider = initDataProviderOrJson(safeOptions.dataProvider);
     remultStatic.defaultDataProvider = () => dataProvider;
-    if (options.ensureSchema === undefined)
-        options.ensureSchema = true;
+    if (safeOptions.ensureSchema === undefined)
+        safeOptions.ensureSchema = true;
     RemultAsyncLocalStorage.enable();
     {
         let allControllers = [];
-        if (!options.entities)
-            options.entities = [...remultStatic.allEntities];
-        if (options.entities)
-            allControllers.push(...options.entities);
-        if (options.controllers)
-            allControllers.push(...options.controllers);
-        options.controllers = allControllers;
+        if (!safeOptions.entities)
+            safeOptions.entities = [...remultStatic.allEntities];
+        if (safeOptions.entities)
+            allControllers.push(...safeOptions.entities);
+        if (safeOptions.controllers)
+            allControllers.push(...safeOptions.controllers);
+        safeOptions.controllers = allControllers;
     }
-    if (options.rootPath === undefined)
-        options.rootPath = '/api';
+    if (safeOptions.rootPath === undefined)
+        safeOptions.rootPath = '/api';
     remultStatic.actionInfo.runningOnServer = true;
-    let bridge = new RemultServerImplementation(new inProcessQueueHandler(options.queueStorage), options, dataProvider, serverCoreOptions);
+    let bridge = new RemultServerImplementation(new inProcessQueueHandler(safeOptions.queueStorage), safeOptions, dataProvider, serverCoreOptions);
     return bridge;
 }
 /* @internal*/
@@ -223,7 +221,7 @@ export class RemultServerImplementation {
                     ;
                     remult.subscriptionServer.openHttpServerStream(origReq, origRes);
                 }));
-                r.route(streamPath + '/subscribe').post(this.process(async (remult, req, res, reqInfo, origRes, origReq) => {
+                r.route(streamPath + '/subscribe').post(this.process(async (remult, _2, res, _, _1, origReq) => {
                     const body = remult.subscriptionServer.subscribeToChannel(await this.coreOptions.getRequestBody(origReq), res, remult);
                 }));
                 r.route(streamPath + '/unsubscribe').post(this.process(async (remult, req, res, reqInfo, origRes, origReq) => {
@@ -284,14 +282,12 @@ export class RemultServerImplementation {
             x.liveQueryStorage = this.liveQueryStorage;
             return await what(x);
         }, {
-            dataProvider,
+            dataProvider: dataProvider,
         });
     }
     process(what) {
         return async (req, origRes) => {
-            const genReq = req
-                ? this.coreOptions.buildGenericRequestInfo(req)
-                : undefined;
+            const genReq = req ? this.coreOptions.buildGenericRequestInfo(req) : {};
             if (req) {
                 if (!genReq.query) {
                     genReq.query = req['_tempQuery'];
@@ -300,13 +296,14 @@ export class RemultServerImplementation {
                     genReq.params = req['_tempParams'];
             }
             let myReq = new RequestBridgeToDataApiRequest(genReq);
-            let myRes = new ResponseBridgeToDataApiResponse(origRes, req, this.options.error);
+            let myRes = new ResponseBridgeToDataApiResponse(origRes, req, genReq, this.options.error);
             try {
                 if (remultStatic.asyncContext.isInInitRequest())
                     return await what(remultStatic.asyncContext.getStore().remult, myReq, myRes, genReq, origRes, req);
                 else
                     await this.runWithRemult(async (remult) => {
                         if (req) {
+                            remult.context.request = req;
                             remultStatic.asyncContext.setInInitRequest(true);
                             try {
                                 let user;
@@ -767,6 +764,7 @@ class RequestBridgeToDataApiRequest {
 class ResponseBridgeToDataApiResponse {
     r;
     req;
+    genReq;
     handleError;
     forbidden() {
         this.error({ message: 'Forbidden' }, undefined, 403);
@@ -774,9 +772,10 @@ class ResponseBridgeToDataApiResponse {
     setStatus(status) {
         return this.r.status(status);
     }
-    constructor(r, req, handleError) {
+    constructor(r, req, genReq, handleError) {
         this.r = r;
         this.req = req;
+        this.genReq = genReq;
         this.handleError = handleError;
     }
     progress(progress) { }
@@ -819,8 +818,8 @@ class ResponseBridgeToDataApiResponse {
                 message: body.message,
                 httpStatusCode,
                 stack: data.stack?.split('\n'),
-                url: this.req?.url,
-                method: this.req?.method,
+                url: this.genReq?.url,
+                method: this.genReq?.method,
             });
             this.setStatus(httpStatusCode).json(body);
         };
@@ -911,7 +910,7 @@ export class EntityQueueStorage {
         return (this.sync = this.sync.then(() => what()));
     }
     async getJobInfo(queuedJobId) {
-        let q = await this.repo.findId(queuedJobId);
+        let q = (await this.repo.findId(queuedJobId));
         let lastProgress = undefined;
         return {
             userId: q.userId,
@@ -1009,8 +1008,9 @@ export class RouteImplementation {
                     res({ statusCode });
                 }
                 flush() {
-                    if (gRes.flush)
+                    if (isOfType(gRes, 'flush')) {
                         gRes.flush();
+                    }
                 }
                 statusCode = 200;
                 json(data) {
@@ -1047,7 +1047,7 @@ export class RouteImplementation {
     }
     middleware(origReq, res, next) {
         const req = this.coreOptions.buildGenericRequestInfo(origReq);
-        let theUrl = req.url;
+        let theUrl = req.url?.toString() || '';
         if (theUrl.startsWith('/'))
             //next sends a partial url '/api/tasks' and not the full url
             theUrl = 'http://stam' + theUrl;
@@ -1107,22 +1107,22 @@ export class RouteImplementation {
     }
 }
 let JobsInQueueEntity = class JobsInQueueEntity extends IdEntity {
-    userId;
-    url;
+    userId = '';
+    url = '';
     submitTime;
     doneTime;
-    result;
-    done;
-    error;
-    progress;
+    result = '';
+    done = false;
+    error = false;
+    progress = 0;
 };
 __decorate([
     Fields.string(),
-    __metadata("design:type", String)
+    __metadata("design:type", Object)
 ], JobsInQueueEntity.prototype, "userId", void 0);
 __decorate([
     Fields.string(),
-    __metadata("design:type", String)
+    __metadata("design:type", Object)
 ], JobsInQueueEntity.prototype, "url", void 0);
 __decorate([
     Fields.date(),
@@ -1134,19 +1134,19 @@ __decorate([
 ], JobsInQueueEntity.prototype, "doneTime", void 0);
 __decorate([
     Fields.string(),
-    __metadata("design:type", String)
+    __metadata("design:type", Object)
 ], JobsInQueueEntity.prototype, "result", void 0);
 __decorate([
     Fields.boolean(),
-    __metadata("design:type", Boolean)
+    __metadata("design:type", Object)
 ], JobsInQueueEntity.prototype, "done", void 0);
 __decorate([
     Fields.boolean(),
-    __metadata("design:type", Boolean)
+    __metadata("design:type", Object)
 ], JobsInQueueEntity.prototype, "error", void 0);
 __decorate([
     Fields.number(),
-    __metadata("design:type", Number)
+    __metadata("design:type", Object)
 ], JobsInQueueEntity.prototype, "progress", void 0);
 JobsInQueueEntity = __decorate([
     Entity(undefined, {

package/esm/src/CompoundIdField.js

@@ -36,19 +36,19 @@ export class CompoundIdField {
         });
         return r;
     }
-    options;
+    options = {};
     get valueConverter() {
         throw new Error('cant get value converter of compound id');
     }
     target;
-    readonly;
-    allowNull;
-    dbReadOnly;
-    isServerExpression;
-    key;
-    caption;
-    inputType;
-    dbName;
+    readonly = true;
+    allowNull = false;
+    dbReadOnly = false;
+    isServerExpression = false;
+    key = '';
+    caption = '';
+    inputType = '';
+    dbName = '';
     valueType;
     isEqualTo(value) {
         let result = {};

package/esm/src/data-api.js

@@ -286,7 +286,7 @@ export class DataApi {
     async updateManyImplementation(response, request, body) {
         try {
             let where = await this.buildWhere(request, body);
-            Filter.throwErrorIfFilterIsEmpty(where, 'deleteMany');
+            Filter.throwErrorIfFilterIsEmpty(where, 'updateMany');
             return await doTransaction(this.remult, async () => {
                 let updated = 0;
                 for await (const x of this.repository.query({

package/esm/src/data-providers/json-entity-opfs-storage.js

@@ -2,17 +2,21 @@ export class JsonEntityOpfsStorage {
     //@internal
     opfsRoot;
     async getItem(entityDbName) {
-        if (!this.opfsRoot) {
-            this.opfsRoot = await navigator.storage.getDirectory();
-        }
-        const opfsFile = await this.opfsRoot.getFileHandle(entityDbName + '.json', {
+        const opfsFile = await (await this.init()).getFileHandle(entityDbName + '.json', {
             create: true,
         });
         const readable = await opfsFile.getFile();
         return await readable.text();
     }
+    //@internal
+    async init() {
+        if (!this.opfsRoot) {
+            this.opfsRoot = await navigator.storage.getDirectory();
+        }
+        return this.opfsRoot;
+    }
     async setItem(entityDbName, json) {
-        const opfsFile = await this.opfsRoot.getFileHandle(entityDbName + '.json', {
+        const opfsFile = await await (await this.init()).getFileHandle(entityDbName + '.json', {
             create: true,
         });
         const writable = await opfsFile.createWritable();

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

@@ -193,16 +193,16 @@ export class SqlDatabase {
 }
 const icons = new Map([
     // CRUD
-    ['INSERT', '⚪'],
-    ['SELECT', '🔵'],
-    ['UPDATE', '🟣'],
-    ['DELETE', '🟤'],
+    ['INSERT', '⚪'], // Used to insert new data into a database.
+    ['SELECT', '🔵'], // Used to select data from a database and retrieve it.
+    ['UPDATE', '🟣'], // Used to update existing data within a database.
+    ['DELETE', '🟤'], // Used to delete existing data from a database.
     // Additional
-    ['CREATE', '🟩'],
-    ['ALTER', '🟨'],
-    ['DROP', '🟥'],
-    ['TRUNCATE', '⬛'],
-    ['GRANT', '🟪'],
+    ['CREATE', '🟩'], // Used to create a new table, or database.
+    ['ALTER', '🟨'], // Used to modify an existing database object, such as a table.
+    ['DROP', '🟥'], // Used to delete an entire table or database.
+    ['TRUNCATE', '⬛'], // Used to remove all records from a table, including all spaces allocated for the records are removed.
+    ['GRANT', '🟪'], // Used to give a specific user permission to perform certain tasks.
     ['REVOKE', '🟫'], // Used to take back permissions from a user.
 ]);
 class LogSQLCommand {

package/esm/src/filter/filter-consumer-bridge-to-sql-request.js

@@ -211,7 +211,7 @@ export function isDbReadonly(field, dbNames) {
         (field.options.sqlExpression && field.dbName != dbNames.$dbNameOf(field)));
 }
 export function shouldNotCreateField(field, dbNames) {
-    return (field.isServerExpression ||
+    return Boolean(field.isServerExpression ||
         (field.options.sqlExpression && field.dbName != dbNames.$dbNameOf(field)));
 }
 export function shouldCreateEntity(entity, e) {
@@ -255,6 +255,7 @@ async function internalDbNamesOf(repo, wrapIdentifierOrOptions, forceSqlExpressi
             else if (options.tableName === true) {
                 r = result.$entityName + '.' + r;
             }
+        ;
         result[field.key] = r;
     }
     return result;
@@ -287,6 +288,7 @@ export async function fieldDbName(f, meta, wrapIdentifier = (x) => x, forceSqlEx
                     return "recursive sqlExpression call for field '" + f.key + "'. ";
                 }
                 try {
+                    ;
                     f[sqlExpressionInProgressKey] = true;
                     result = await f.options.sqlExpression(meta);
                     f.options.sqlExpression = () => result;

package/esm/src/filter/filter-interfaces.js

@@ -285,8 +285,8 @@ export class Filter {
         this.__applyToConsumer(r);
         return r.result;
     }
-    //@internal
     static async translateCustomWhere(r, entity, remult) {
+        // Used in hagai
         let f = new customTranslator(async (filterKey, custom) => {
             let r = [];
             for (const key in entity.entityType) {

package/esm/src/live-query/LiveQueryClient.js

@@ -185,7 +185,6 @@ export class LiveQueryClient {
     }
 }
 class MessageChannel {
-    id;
     unsubscribe = () => { };
     async handle(message) {
         for (const l of this.listeners) {

package/esm/src/remult-proxy.js

@@ -73,9 +73,7 @@ export class RemultProxy {
             },
             //@ts-ignore
             [getInternalKey]() {
-                return self
-                    .remultFactory()
-                    .repo(...args)[getInternalKey]();
+                return self.remultFactory().repo(...args)[getInternalKey]();
             },
             relations: (args2) => self
                 .remultFactory()

package/esm/src/remult-static.js

@@ -24,6 +24,7 @@ let x = {
 if ((typeof process !== 'undefined' &&
     process.env['IGNORE_GLOBAL_REMULT_IN_TESTS']) ||
     typeof globalThis[remultStaticKey] === 'undefined') {
+    ;
     globalThis[remultStaticKey] = x;
     x.remultFactory = () => defaultFactory();
 }

package/esm/src/remult3/Fields.js

@@ -6,6 +6,7 @@ import { Validators, createValueValidator, getEnumValues, } from '../validators.
 import { relationInfoMemberInOptions } from './relationInfoMember.js';
 import { remultStatic } from '../remult-static.js';
 import { addValidator } from './addValidator.js';
+import { isOfType } from '../isOfType.js';
 const validateNumber = createValueValidator((x) => {
     return !isNaN(x) && isFinite(x);
 });
@@ -98,7 +99,7 @@ export class Fields {
             },
         }, ...options);
     }
-    // static id<entityType = any>(
+    // static id<entityType = unknown>(
     //   options?: FieldOptions<entityType, string> & { idFactory?: () => string },
     // ): ClassFieldDecorator<entityType, string | undefined> {
     //   let buildId = options?.idFactory ?? createId
@@ -148,12 +149,13 @@ export class Fields {
     }
     static enum(enumType, ...options) {
         let valueConverter;
-        return Field(() => 
+        return Field(
         //@ts-ignore
-        enumType(), {
+        () => enumType(), {
             validate: (entity, event) => Validators.enum(enumType())(entity, event),
             [fieldOptionalValuesFunctionKey]: () => getEnumValues(enumType()),
         }, ...options, (options) => {
+            ;
             options[fieldOptionalValuesFunctionKey] = () => getEnumValues(enumType());
             if (valueConverter === undefined) {
                 let enumObj = enumType();
@@ -273,11 +275,17 @@ export function Field(valueType, ...options) {
             if (r.required) {
                 r.validate = addValidator(r.validate, Validators.required, true);
             }
-            if (r.maxLength) {
-                r.validate = addValidator(r.validate, Validators.maxLength(r.maxLength));
+            if (isOfType(r, 'maxLength')) {
+                let z = r;
+                if (z.maxLength) {
+                    z.validate = addValidator(z.validate, Validators.maxLength(z.maxLength));
+                }
             }
-            if (r.minLength) {
-                r.validate = addValidator(r.validate, Validators.minLength(r.minLength));
+            if (isOfType(r, 'minLength')) {
+                let z = r;
+                if (z.minLength) {
+                    z.validate = addValidator(z.validate, Validators.minLength(z.minLength));
+                }
             }
             if (!r.valueType && valueType) {
                 r.valueType = valueType();