remult 0.22.1 → 0.22.3

package/esm/core/remult-mongo.d.ts

@@ -1,24 +0,0 @@
-import type { MongoClient, Db, ClientSession } from 'mongodb';
-import { DataProvider, EntityDataProvider, EntityFilter, EntityMetadata, Remult } from '.';
-import { RepositoryOverloads } from './src/remult3';
-export declare class MongoDataProvider implements DataProvider {
-    private db;
-    private client;
-    constructor(db: Db, client: MongoClient, options?: {
-        session?: ClientSession;
-        disableTransactions?: boolean;
-    });
-    session?: ClientSession;
-    disableTransactions: boolean;
-    static getDb(remult?: Remult): {
-        db: Db;
-        session: ClientSession | undefined;
-    };
-    getEntityDataProvider(entity: EntityMetadata<any>): EntityDataProvider;
-    transaction(action: (dataProvider: DataProvider) => Promise<void>): Promise<void>;
-    static filterToRaw<entityType>(entity: RepositoryOverloads<entityType>, condition: EntityFilter<entityType>): Promise<{
-        $and: any[];
-    } | {
-        $and?: undefined;
-    }>;
-}

package/esm/core/remult-mongo.js

@@ -1,254 +0,0 @@
-import { CompoundIdField, Filter } from '.';
-import { dbNamesOf } from './src/filter/filter-consumer-bridge-to-sql-request';
-import { getRepository } from './src/remult3';
-import { remult as remultContext } from './src/remult-proxy';
-export class MongoDataProvider {
-    db;
-    client;
-    constructor(db, client, options) {
-        this.db = db;
-        this.client = client;
-        this.session = options?.session;
-        this.disableTransactions = options?.disableTransactions;
-    }
-    session;
-    disableTransactions = false;
-    static getDb(remult) {
-        const r = (remult || remultContext).dataProvider;
-        if (!r.db)
-            throw "the data provider is not a MongoDataProvider";
-        return { db: r.db, session: r.session };
-    }
-    getEntityDataProvider(entity) {
-        return new MongoEntityDataProvider(this.db, entity, this.session);
-    }
-    async transaction(action) {
-        let session = await this.client.startSession();
-        session.startTransaction();
-        const db = this.client.db(this.db.databaseName);
-        try {
-            await action(new MongoDataProvider(db, undefined, { session }));
-            await session.commitTransaction();
-        }
-        catch (err) {
-            await session.abortTransaction();
-            throw err;
-        }
-        finally {
-            await session.endSession();
-        }
-    }
-    static async filterToRaw(entity, condition) {
-        const repo = getRepository(entity);
-        var b = new FilterConsumerBridgeToMongo(await dbNamesOf(repo.metadata));
-        b._addWhere = false;
-        await (await (repo.translateWhereToFilter(condition))).__applyToConsumer(b);
-        let r = await b.resolveWhere();
-        return r;
-    }
-}
-const NULL = { $null: "$null" };
-function isNull(x) {
-    return x?.$null === NULL.$null;
-}
-class MongoEntityDataProvider {
-    db;
-    entity;
-    session;
-    constructor(db, entity, session) {
-        this.db = db;
-        this.entity = entity;
-        this.session = session;
-    }
-    translateFromJson(row, nameProvider) {
-        let result = {};
-        for (const col of this.entity.fields) {
-            let val = row[nameProvider.$dbNameOf(col)];
-            if (isNull(val))
-                val = null;
-            result[col.key] = col.valueConverter.fromDb(val);
-        }
-        return result;
-    }
-    translateToJson(row, nameProvider) {
-        let result = {};
-        for (const col of this.entity.fields) {
-            let val = col.valueConverter.toDb(row[col.key]);
-            if (val === null)
-                val = NULL;
-            result[nameProvider.$dbNameOf(col)] = val;
-        }
-        return result;
-    }
-    async count(where) {
-        const { collection, e } = await this.collection();
-        let x = new FilterConsumerBridgeToMongo(e);
-        where.__applyToConsumer(x);
-        let w = await x.resolveWhere();
-        return await collection.countDocuments(w, { session: this.session });
-    }
-    async find(options) {
-        let { collection, e } = await this.collection();
-        let x = new FilterConsumerBridgeToMongo(e);
-        if (options?.where)
-            options.where.__applyToConsumer(x);
-        let where = await x.resolveWhere();
-        let op = {
-            session: this.session
-        };
-        if (options.limit) {
-            op.limit = options.limit;
-            if (options.page) {
-                op.skip = (options.page - 1) * options.limit;
-            }
-        }
-        if (options.orderBy) {
-            op.sort = {};
-            for (const s of options.orderBy.Segments) {
-                op.sort[e.$dbNameOf(s.field)] = s.isDescending ? -1 : 1;
-            }
-        }
-        return await Promise.all(await collection.find(where, op).map(x => this.translateFromJson(x, e)).toArray());
-    }
-    async update(id, data) {
-        let { collection, e } = await this.collection();
-        let f = new FilterConsumerBridgeToMongo(e);
-        Filter.fromEntityFilter(this.entity, this.entity.idMetadata.getIdFilter(id)).__applyToConsumer(f);
-        let resultFilter = this.entity.idMetadata.getIdFilter(id);
-        if (data.id != undefined)
-            resultFilter = this.entity.idMetadata.getIdFilter(data.id);
-        for (const x of this.entity.fields) {
-            if (x instanceof CompoundIdField) {
-                resultFilter = x.resultIdFilter(id, data);
-            }
-        }
-        let newR = {};
-        let keys = Object.keys(data);
-        for (const f of this.entity.fields) {
-            if (!f.dbReadOnly && !f.isServerExpression) {
-                if (keys.includes(f.key)) {
-                    newR[f.key] = f.valueConverter.toJson(data[f.key]);
-                }
-            }
-        }
-        let r = await collection.updateOne(await f.resolveWhere(), {
-            $set: newR
-        }, { session: this.session });
-        return this.find({ where: Filter.fromEntityFilter(this.entity, resultFilter) }).then(y => y[0]);
-    }
-    async delete(id) {
-        const { e, collection } = await this.collection();
-        let f = new FilterConsumerBridgeToMongo(e);
-        Filter.fromEntityFilter(this.entity, this.entity.idMetadata.getIdFilter(id)).__applyToConsumer(f);
-        collection.deleteOne(await f.resolveWhere(), { session: this.session });
-    }
-    async insert(data) {
-        let { collection, e } = await this.collection();
-        let r = await collection.insertOne(await this.translateToJson(data, e), { session: this.session });
-        return await this.translateFromJson(await collection.findOne({ _id: r.insertedId }, { session: this.session }), e);
-    }
-    async collection() {
-        const e = await dbNamesOf(this.entity);
-        const collection = this.db.collection(e.$entityName);
-        return { e, collection };
-    }
-}
-class FilterConsumerBridgeToMongo {
-    nameProvider;
-    _addWhere = true;
-    promises = [];
-    result = [];
-    async resolveWhere() {
-        while (this.promises.length > 0) {
-            let p = this.promises;
-            this.promises = [];
-            for (const pr of p) {
-                await pr;
-            }
-        }
-        if (this.result.length > 0)
-            return { $and: this.result.map(x => x()) };
-        else
-            return {};
-    }
-    constructor(nameProvider) {
-        this.nameProvider = nameProvider;
-    }
-    custom(key, customItem) {
-        throw new Error("Custom filter should be translated before it gets here");
-    }
-    or(orElements) {
-        this.promises.push((async () => {
-            let result = [];
-            for (const element of orElements) {
-                let f = new FilterConsumerBridgeToMongo(this.nameProvider);
-                f._addWhere = false;
-                element.__applyToConsumer(f);
-                let where = await f.resolveWhere();
-                if (where?.$and?.length > 0) {
-                    result.push(where);
-                }
-                else
-                    return; //since empty or is all rows;
-            }
-            this.result.push(() => ({
-                $or: result
-            }));
-        })());
-    }
-    isNull(col) {
-        this.add(col, NULL, "$eq");
-    }
-    isNotNull(col) {
-        this.add(col, NULL, "$ne");
-    }
-    isIn(col, val) {
-        this.result.push(() => ({
-            [this.nameProvider.$dbNameOf(col)]: {
-                $in: val.map(x => col.valueConverter.toDb(x))
-            }
-        }));
-    }
-    isEqualTo(col, val) {
-        this.add(col, val, "$eq");
-    }
-    isDifferentFrom(col, val) {
-        this.add(col, val, "$ne");
-    }
-    isGreaterOrEqualTo(col, val) {
-        this.add(col, val, "$gte");
-    }
-    isGreaterThan(col, val) {
-        this.add(col, val, "$gt");
-    }
-    isLessOrEqualTo(col, val) {
-        this.add(col, val, "$lte");
-    }
-    isLessThan(col, val) {
-        this.add(col, val, "$lt");
-    }
-    containsCaseInsensitive(col, val) {
-        throw "containsCaseInsensitive not yet implemented";
-        // this.promises.push(col.getDbName().then(colName => {
-        //     this.result.push(b => b.whereRaw(
-        //         'lower (' + colName + ") like lower ('%" + val.replace(/'/g, '\'\'') + "%')"));
-        // }));
-    }
-    add(col, val, operator) {
-        this.result.push(() => ({
-            [this.nameProvider.$dbNameOf(col)]: { [operator]: isNull(val) ? val : col.valueConverter.toDb(val) }
-        }));
-    }
-    databaseCustom(databaseCustom) {
-        throw "error";
-        //   this.promises.push((async () => {
-        //     if (databaseCustom?.buildSql) {
-        //       let item = new CustomSqlFilterBuilder(this.knex);
-        //       await databaseCustom.buildSql(item);
-        //       if (item.sql) {
-        //         this.addToWhere("(" + item.sql + ")");
-        //       }
-        //     }
-        //   })());
-    }
-}

package/esm/core/server/JsonEntityFileStorage.d.ts

@@ -1,10 +0,0 @@
-import { JsonDataProvider, JsonEntityStorage } from '../index';
-export declare class JsonEntityFileStorage implements JsonEntityStorage {
-    private folderPath;
-    getItem(entityDbName: string): string;
-    setItem(entityDbName: string, json: string): void;
-    constructor(folderPath: string);
-}
-export declare class JsonFileDataProvider extends JsonDataProvider {
-    constructor(folderPath: string);
-}

package/esm/core/server/JsonEntityFileStorage.js

@@ -1,25 +0,0 @@
-import * as path from 'path';
-import * as fs from 'fs';
-import { JsonDataProvider } from '../index';
-export class JsonEntityFileStorage {
-    folderPath;
-    getItem(entityDbName) {
-        let fn = path.join(this.folderPath, entityDbName) + '.json';
-        if (fs.existsSync(fn)) {
-            return fs.readFileSync(fn).toString();
-        }
-        return undefined;
-    }
-    setItem(entityDbName, json) {
-        if (!fs.existsSync(this.folderPath)) {
-            fs.mkdirSync(this.folderPath);
-        }
-        return fs.writeFileSync(path.join(this.folderPath, entityDbName) + '.json', json);
-    }
-    constructor(folderPath) {
-        this.folderPath = folderPath;
-    }
-}
-export class JsonFileDataProvider extends JsonDataProvider {
-    constructor(folderPath) { super(new JsonEntityFileStorage(folderPath)); }
-}

package/esm/core/server/core.d.ts

@@ -1,4 +0,0 @@
-export { queuedJobInfo, QueueStorage, GenericRequestInfo, GenericRequestHandler, GenericResponse, GenericRouter, createRemultServerCore, RemultServerOptions, SpecificRoute, RemultServer } from './expressBridge';
-export { JsonEntityFileStorage, JsonFileDataProvider } from './JsonEntityFileStorage';
-export { SseSubscriptionServer } from '../SseSubscriptionServer';
-export { DataProviderLiveQueryStorage } from '../live-query/data-provider-live-query-storage';

package/esm/core/server/core.js

@@ -1,4 +0,0 @@
-export { createRemultServerCore } from './expressBridge';
-export { JsonEntityFileStorage, JsonFileDataProvider } from './JsonEntityFileStorage';
-export { SseSubscriptionServer } from '../SseSubscriptionServer';
-export { DataProviderLiveQueryStorage } from '../live-query/data-provider-live-query-storage';

package/esm/core/server/expressBridge.d.ts

@@ -1,182 +0,0 @@
-import { ActionInterface, queuedJobInfoResponse } from '../src/server-action';
-import type { DataProvider } from '../src/data-interfaces';
-import { DataApi, DataApiRequest, DataApiResponse } from '../src/data-api';
-import { AllowedForInstance, Remult, UserInfo } from '../src/context';
-import type { ClassType } from '../classType';
-import { EntityMetadata, IdEntity, Repository } from '../src/remult3';
-import { LiveQueryStorage, PerformWithContext, SubscriptionServer } from '../src/live-query/SubscriptionServer';
-export interface RemultServerOptions<RequestType> {
-    /**Entities to use for the api */
-    entities?: ClassType<any>[];
-    /**Controller to use for the api */
-    controllers?: ClassType<any>[];
-    /** Will be called to get the current user based on the current request */
-    getUser?: (request: RequestType) => Promise<UserInfo | undefined>;
-    /** Will be called for each request and can be used for configuration */
-    initRequest?: (request: RequestType, options: InitRequestOptions) => Promise<void>;
-    /** Will be called once the server is loaded and the data provider is ready */
-    initApi?: (remult: Remult) => void | Promise<void>;
-    /** Data Provider to use for the api.
-     *
-     * @see [Connecting to a Database](https://remult.dev/docs/databases.html).
-    */
-    dataProvider?: DataProvider | Promise<DataProvider> | (() => Promise<DataProvider | undefined>);
-    /** Will create tables and columns in supporting databases. default: true
-     *
-     * @description
-     * when set to true, it'll create entities that do not exist, and add columns that are missing.
-    */
-    ensureSchema?: boolean;
-    /** The path to use for the api, default:/api
-     *
-     * @description
-     * If you want to use a different api path adjust this field
-    */
-    rootPath?: string;
-    /** The default limit to use for find requests that did not specify a limit */
-    defaultGetLimit?: number;
-    /** When set to true (default) it'll console log each api endpoint that is created */
-    logApiEndPoints?: boolean;
-    /** A subscription server to use for live query and message channels */
-    subscriptionServer?: SubscriptionServer;
-    /** A storage to use to store live queries, relevant mostly for serverless scenarios or larger scales */
-    liveQueryStorage?: LiveQueryStorage;
-    /** Used to store the context relevant info for re running a live query */
-    contextSerializer?: {
-        serialize(remult: Remult): Promise<any>;
-        deserialize(json: any, options: InitRequestOptions): Promise<void>;
-    };
-    /** Storage to use for backend methods that use queue */
-    queueStorage?: QueueStorage;
-}
-export interface InitRequestOptions {
-    liveQueryStorage: LiveQueryStorage;
-    readonly remult: Remult;
-}
-export declare function createRemultServerCore<RequestType>(options: RemultServerOptions<RequestType>, serverCoreOptions: ServerCoreOptions<RequestType>): RemultServer<RequestType>;
-export type GenericRequestHandler = (req: GenericRequestInfo, res: GenericResponse, next: VoidFunction) => void;
-export interface ServerHandleResponse {
-    data?: any;
-    statusCode: number;
-}
-export interface RemultServer<RequestType> extends RemultServerCore<RequestType> {
-    withRemult(req: RequestType, res: GenericResponse, next: VoidFunction): any;
-    registerRouter(r: GenericRouter): void;
-    handle(req: RequestType, gRes?: GenericResponse): Promise<ServerHandleResponse | undefined>;
-    withRemultPromise<T>(request: RequestType, what: () => Promise<T>): Promise<T>;
-}
-export interface RemultServerCore<RequestType> {
-    getRemult(req: RequestType): Promise<Remult>;
-    openApiDoc(options: {
-        title: string;
-        version?: string;
-    }): any;
-}
-export type GenericRouter = {
-    route(path: string): SpecificRoute;
-};
-export type SpecificRoute = {
-    get(handler: GenericRequestHandler): SpecificRoute;
-    put(handler: GenericRequestHandler): SpecificRoute;
-    post(handler: GenericRequestHandler): SpecificRoute;
-    delete(handler: GenericRequestHandler): SpecificRoute;
-};
-export interface GenericRequestInfo {
-    url?: string;
-    method?: any;
-    query?: any;
-    params?: any;
-}
-export interface GenericResponse {
-    json(data: any): any;
-    status(statusCode: number): GenericResponse;
-    end(): any;
-}
-export declare class RemultServerImplementation<RequestType> implements RemultServer<RequestType> {
-    queue: inProcessQueueHandler;
-    options: RemultServerOptions<any>;
-    dataProvider: DataProvider | Promise<DataProvider>;
-    private coreOptions;
-    private entitiesMetaData;
-    liveQueryStorage: LiveQueryStorage;
-    constructor(queue: inProcessQueueHandler, options: RemultServerOptions<any>, dataProvider: DataProvider | Promise<DataProvider>, coreOptions: ServerCoreOptions<RequestType>, entitiesMetaData: EntityMetadata[]);
-    withRemultPromise<T>(request: RequestType, what: () => Promise<T>): Promise<T>;
-    getEntities(): EntityMetadata<any>[];
-    runWithSerializedJsonContextData: PerformWithContext;
-    subscriptionServer: SubscriptionServer;
-    withRemult: (req: RequestType, res: GenericResponse, next: VoidFunction) => void;
-    routeImpl: RouteImplementation<RequestType>;
-    getRouteImpl(): RouteImplementation<RequestType>;
-    handle(req: RequestType, gRes?: GenericResponse): Promise<ServerHandleResponse>;
-    registeredRouter: boolean;
-    registerRouter(r: GenericRouter): void;
-    serializeContext(remult: Remult): Promise<{
-        user: UserInfo | undefined;
-        context: undefined;
-    }>;
-    add(key: string, dataApiFactory: ((req: Remult) => DataApi), r: GenericRouter): void;
-    private runWithRemult;
-    process(what: (remult: Remult, myReq: DataApiRequest, myRes: DataApiResponse, genReq: GenericRequestInfo, origRes: GenericResponse, origReq: RequestType) => Promise<void>): (req: RequestType, origRes: GenericResponse) => Promise<void>;
-    getRemult(req: RequestType): Promise<Remult>;
-    hasQueue: boolean;
-    addAction(action: ActionInterface, r: GenericRouter): void;
-    openApiDoc(options: {
-        title: string;
-        version?: string;
-    }): any;
-    backendMethodsOpenApi: {
-        path: string;
-        allowed: AllowedForInstance<any>;
-        tag: string;
-    }[];
-}
-declare class inProcessQueueHandler {
-    private storage;
-    constructor(storage: QueueStorage);
-    submitJob(url: string, req: Remult, body: any): Promise<string>;
-    mapQueuedAction(url: string, what: (data: any, r: Remult, res: DataApiResponse) => void): void;
-    actions: Map<string, (data: any, r: Remult, res: DataApiResponse) => void>;
-    getJobInfo(queuedJobId: string): Promise<queuedJobInfo>;
-}
-export interface queuedJobInfo {
-    info: queuedJobInfoResponse;
-    userId: string;
-    setErrorResult(error: any): void;
-    setResult(result: any): void;
-    setProgress(progress: number): void;
-}
-export interface QueueStorage {
-    createJob(url: string, userId: string): Promise<string>;
-    getJobInfo(queuedJobId: string): Promise<queuedJobInfo>;
-}
-export declare class EntityQueueStorage implements QueueStorage {
-    private repo;
-    constructor(repo: Repository<JobsInQueueEntity>);
-    sync: Promise<any>;
-    doSync<T>(what: () => Promise<T>): Promise<any>;
-    getJobInfo(queuedJobId: string): Promise<queuedJobInfo>;
-    createJob(url: string, userId: string): Promise<string>;
-}
-declare class RouteImplementation<RequestType> {
-    private coreOptions;
-    constructor(coreOptions: ServerCoreOptions<RequestType>);
-    map: Map<string, Map<string, GenericRequestHandler>>;
-    route(path: string): SpecificRoute;
-    handle(req: RequestType, gRes?: GenericResponse): Promise<ServerHandleResponse | undefined>;
-    middleware(origReq: RequestType, res: GenericResponse, next: VoidFunction): void;
-}
-export declare class JobsInQueueEntity extends IdEntity {
-    userId: string;
-    url: string;
-    submitTime: Date;
-    doneTime: Date;
-    result: string;
-    done: boolean;
-    error: boolean;
-    progress: number;
-}
-export interface ServerCoreOptions<RequestType> {
-    buildGenericRequestInfo(req: RequestType): GenericRequestInfo;
-    getRequestBody(req: RequestType): Promise<any>;
-}
-export {};