remult 0.21.1 → 0.22.0

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

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1,254 @@
+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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,25 @@
+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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,182 @@
+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 {};